I anticipate that in the next 700 years, computers will be massively parallel. Humankind seeks to enhance computer performance in the era of big data. This goal has become increasingly challenging following the breakdown of Dennard scaling around 2005, indicating that the performance of sequential computers is unlikely to improve further. Consequently, both servers and personal computers have adopted multi-core systems. This challenge is compounded by the end of Moore's Law, which signifies our diminishing ability to benefit from denser electronic circuits. It appears that the primary pathway to optimizing performance now lies in specialization, focusing on exploiting the parallelism in workloads. Due to these technological trends, I foresee that future computers will be massively parallel.
However, we are not yet fully equipped for the era of massive parallelism. The principal challenge is managing shared mutable states, a key aspect of concurrency. Coordinating multiple cores and resources requires their inputs and outputs to be synchronized through shared mutable states like memory. Yet, managing these states is inherently difficult, both in theory and practice. For instance, with thousands or millions of cores, how can we efficiently synchronize concurrent access to shared memory? In the face of nondeterministic thread execution interleaving, how can we ensure the safety of a concurrent program? And considering compiler and hardware optimizations, what constitutes the correct specification of a concurrent data structure?
Fortunately, in the past ten years, the theory of shared mutable states has made significant advances, greatly facilitating the design and analysis of practical systems utilizing these states. Therefore, in this course, we will explore recent theories of shared mutable states and their application in real-world systems.
This course is designed for senior undergraduate or graduate students in computer science and related disciplines who have an interest in the contemporary theory and practice of parallel computer systems. The course aims to equip students with the ability to:
It is strongly recommended that students have completed courses in:
A solid foundation in these areas is crucial for success in this course.
Other recommended knowledge that will be beneficial:
Ensure you are proficient with the following development tools:
Git: Essential for downloading homework templates and managing your development process. If you're new to Git, please complete this tutorial.
Follow these steps to set up your repository:
$ git clone --origin upstream git@github.com:kaist-cp/cs431.git
$ cd cs431
$ git remote -v
upstream git@github.com:kaist-cp/cs431.git (fetch)
upstream git@github.com:kaist-cp/cs431.git (push)upstream/main:
$ git fetch upstream
$ git merge upstream/mainFor managing your development on a Git server, create a private repository:
$ git remote add origin git@github.com:<github-id>/cs431.git
$ git remote -v
origin git@github.com:<github-id>/cs431.git (fetch)
origin git@github.com:<github-id>/cs431.git (push)
upstream git@github.com:kaist-cp/cs431.git (fetch)
upstream git@github.com:kaist-cp/cs431.git (push)$ git push -u origin mainRust: The programming language for homework assignments. Rust's ownership type system significantly simplifies the development of large-scale system software.
ChatGPT or other Large Language Models (LLMs) (optional): Useful for completing your homework.
Visual Studio Code (optional): Recommended for developing your homework, although you may use any editor of your preference.
Single Sign On (SSO): Use the following SSO credentials to access gg and the development server:
IMPORTANT: READ CAREFULLY. THIS IS A SERIOUS MATTER.
Sign the KAIST CS Honor Code for this semester. Failure to do so may lead to expulsion from the course.
We will employ sophisticated tools to detect code plagiarism.
Dates & Times: April 15th (Mon), June 10th (Mon), 13:00-15:00
Location: Room 2443, Building E3-1, KAIST
Physical attendance is required. If necessary, online participation via Zoom will be accommodated.
You are expected to bring your own laptop. Laptops can also be borrowed from the School of Computing Administration Team.
A quiz must be completed on the Course Management website for each session (if any). Quizzes should be completed by the end of the day.
Failing to attend a significant number of sessions will result in an automatic grade of F.
kaist-cp-class account for login.@kaist.ac.kr email address.Course-related announcements and information will be posted on the course website and the GitHub issue tracker. It is expected that you read all announcements within 24 hours of their posting. Watching the repository is highly recommended for automatic email notifications of new announcements.
Questions about course materials and assignments should be posted in the course repository's issue tracker.
Email inquiries should be reserved for confidential or personal matters. Questions not adhering to this guideline (e.g., course material queries via email) will not be addressed.
Office hours will not cover new questions. Check the issue tracker for similar questions before attending. If your question is not listed, post it as a new issue for discussion. Office hour discussions will focus on unresolved issues.
Emails to the instructor or head TA should start with "CS431:" in the subject line, followed by a brief description. Include your name and student number in the email. Emails lacking this information (e.g., those without a student number) will not receive a response.
If attending remotely via Zoom (https://kaist.zoom.us/my/jeehoon.kang), set your Zoom name to <your student number> <your name> (e.g., 20071163 강지훈).
Instructions for changing your Zoom name can be found here.
The course is conducted in English. However, you may ask questions in Korean, which will be translated into English.
1830eaed90e5986c75320daaf131bd3730b8575e866c4e92935a690e7c2a0717