An introduction to shared-memory concurrent programming and hardware/software co-design, with examples related to operating systems.
CMSC 240 or permission of instructor. Specifically, CMSC 356 requires
- familiarity with basic microprocessor design and assembly-language programming (from CMSC 240)
- skill in high-level imperative, functional, and object-oriented programming and an understanding of program execution (from CMSC 240's prerequisites).
Course grades will be based primarily upon:
- Programming/hardware-design projects, both solo and team (50%)
- Exams (40-45%)
- Participation, including attempting 'mini-homework' assignments, participating in in-class exercises, and attending 'interactive lab review/grading' meetings (5-50%)
Note that timely participation in scheduling activities at the start of the course is required to remain enrolled in the course.
Lab work must be turned in on time; work submitted late without an extension confirmed 24 hours before the due date will lose credit, declining over 12 hours to a maximum score on that lab of 50% (i.e., 1/2 credit for noon Wednesday submission of a lab due "any time Tuesday"); work submitted more than one week late without a note from the dean will recieve no credit. Note that a total course score of 50% of the points is the line between a grade of 0.0 (<50%) 1.0 (>=50%).
A book that covers basic multi-threaded programming concepts including threads, data races, and monitors (i.e., synchronized methods and blocks, wait and notify), and also covers many more advanced elements such as semaphores, actors, and transactions, either:
- Learning Concurrent Programming in Scala, by Aleksandar Prokopec (For students who know or want to learn the Scala language or want a book tha follows the structure of the course), or
- Java Concurrency in Practice, by Brian Goetz (For students who know or want to learn the Java language and don't mind skipping around between chapters).
- (See this list of topics and chapters for more detail about topics and chapters)
Information about the HERA architecture used in Haverford's CMSC 240, and about more advanced elements of microprocessors, both:
- The HERA reference manual (available as PDF on the Moodle page, or in the Haverford book store, or via lulu.com)
- Web readings as assigned during the term.
- Programming Concurrency on the JVM, by Venkat Subramaniam, is an excellent reference to the advanced programming techniques dicussed in this course, though the details are somewhat out-of-date as Scala and Akka evolve.
Note that E-books and PDF's of all of the above materials currently cost about $70 total.
The CS Collaboration Policy will govern work in this course; as the semester progresses, we will add detail about what at-the-computer help is acceptable for this course. For now, the big ideas are:
- Read and understand the policy (handed out in class)
- Cite all help other than the professor, T.A., and required/recommended text (you are allowed to cite those if you wish, but it is not required unless you are specifically told otherwise); note that proper citation is sufficient to avoid any charge of academic dishonesty, and we will not be particularly focused on copyright law during lab work.
- It is fine to get help away from the computer, as long as you erase all notes and return to your computer with only the new understanding in your head.
- If you want help at the computer, in a form that is not discussed in our collaborative 'help at the computer' document in the current semester's Google Docs folder (see Moodle), add it to that document.
This course introduces principles of programming in the presence of shared-memory concurrency, as well as principles of hardware/software co-design.
Concurrent programming content focuses on high-level language programming with applicability beyond operating system design. Approaches will include the classic "threads and locks" paradigm, implicit concurrency in the pure functional paradigm, transaction-based programming, and the Actor model. Lectures employ a mixture of Scala and Java; students may choose to complete concurrent-programming exercises in either of these languages, though some combinations of language and paradigm may require that the student assist in the setup of software infrastructure. Lecture examples and lab projects may include operating-system components or fanciful examples of the same concepts in a self-contained project.
Codesign content will focus on the evolution of microprocessor features beyond the basic elements illustrated in CMSC 240 (ALU, registers, branching, load and store), such as input/output systems, multithreading, and memory protection.
Other sources of information:
Information that is expected to stay relatively stable over several years and be relevant to everyone in the course, such as course content prerequisites, is listed on this web page. Semester-specific information can be found on the course Moodle page, which contains weekly topic information, mini-homework assignments, and grade information, as well as links to each semester's GoogleDocs page, which contains details of lab assignments and supporting documents. Scheduling information can be found on the CS356 Google Calendar (note that, if you use Google Calendar, you may want to hit the "+ Google Calendar" button on the lower right side of that calendar page, to add it to your main calendar view).
- CMSC 355 (at Bryn Mawr College) provides a more traditional treatment of operating-system design, with a focus on existing operating systems and their functionality.
- CMSC 287 covers programming techniques for distributed systems, in the context of high-performance scientific computation.