|
|
Under construction!
Description
Multi-threaded and distributed programming is becoming increasingly
important. Existing critical software such as operating systems,
network servers, and database management systems are heavily threaded.
Moreover, chip manufacturers are moving to "Chip-Level
Multiprocessors" (one chip with multiple cores) in an attempt to keep
up with Moore's law. It seems inevitable that threaded programming
will become the norm. At the same time, networking is ubiquitous, and
distributed computation is an attractive way to take advantage of
large amounts of networked computing power. There are many
challenges, however, in terms of scalability, fault tolerance, and
security.
In this course, we will study language-based techniques for
implementing and understanding concurrent and distributed software.
Topics
- Basic Programming Models. We will begin the course by
studying current techniques for writing concurrent and distributed
software, in existing, widely-used languages. We will look briefly at
Java threads, POSIX threads in C, threading in the Linux kernel, and
MPI, among other topics.
- Architectural Support. We will briefly study the
underlying hardware support for running concurrent and distributed
programs. We will look at memory consistency models, network support
for efficient distributed computation, and multi-core processor
characteristics.
- Language Design. The main focus during the semester will
be on studying language-based approaches for writing concurrent and
distributed software. We will look at formalisms such as pi-calculus,
CSP, and ambient calculus. We will also study language designs, such
as Split C, Concurrent ML, Pict, Acute, Cilk, and Titanium, among
others.
- Software Transactions. Software transactions are a recent
hot topic in the design of concurrent languages that we will study.
Instead of the programmer using primitives such as locks, in a
transaction-based system the programmer specifies atomic blocks that
should be serializable. The runtime system actually implements
atomicity, e.g., using optimistic concurrency or pessimistic locking.
- Static and Dynamic Analysis. It is notoriously difficult
to write and debug concurrent and distributed software. We will study
dynamic (run-time) and static (compile-time) techniques for checking
correctnes of concurrent and distributed programs.
Prerequisites
CMSC 631 or another graduate level programming languages course
(838Y/Z), or permission of the instructor. Contact the instructor if
you're interested in taking the class but aren't sure if you have the
background.
Class Structure and Grading
The course will consist mostly of reading and discussing technical
papers on the above topics. Since a major focus of the course is how
to program concurrent and distributed systems, there will be various
small programming tasks during the semester; to reduce the burden in
learning new languages, the responsibility for these will rotate
through class members. There may also be short homework assignments.
The course grade will be made up of (subject to change until the class
starts):
- Class Participation (35%). This consists of (1) written
reviews of the papers we read; (2) short homework or programming projects;
(3) discussion during class; and (4) a presentation on a topic, to be
chosen during the semester
- Project (40%). Students will propose projects
approximately 1/3 of the way through the semester, to be finalized 1/2
way through, and completed by the end of the semester. More details
on the project can be found on the projects web page.
- Final Exam (25%). There will be a comprehensive final
exam, which will count for comp credit.
Academic Dishonesty
The university policy on academic dishonesty is strictly followed.
All graded materials (whether exams, summaries, presentations, or
projects) must be strictly individual efforts. In the case of a group
project or assignment, only collaborations within the group are
permitted.
|