Announcements
Jan 15: The labs started being posted. All feedback is welcome.
Jan 04: Slides and reading material are being posted. (This is a brand
new class and the material is fresh out the oven.) Details about the
labs will follow.
Course Description
So your boss walks in your office and proudly announces he just signed
a fat check for a new super-duper computer. Because it is twice as
powerful as the current one, he says your software is now going to run
that much faster. Question: is that good or bad news?
It used be that that was clearly good news. A more powerful computer
meant a faster CPU. And that meant instructions running faster. Our
software performance automatically benefited from it.
Well, that is not so anymore. If you're reading this on any relatively
modern computer, chances are its clock is between 2 to 3Ghz. The same
as last year's modern computer, and also the year before that. What
changed is that new computers now bring more "cores" -- several mostly
independent CPUs in one chip. Technically, they are faster because
they can execute more instructions in the same unit of time. But if
you benchmark an "old" application, you'll be surprised to see one
core working and all the others idle.
What just happened?! We used to build "sequential" software that
consisted mostly of one flow of instructions. Sequential software
can't take advantage of several cores at once. We now need to learn
how to solve problems and code differently. This course will help it
in that in it we will:
- Understand the ongoing shift in hardware evolution towards multicores and how it affects software development
- Befriend threads and understand software models that build upon them
- Learn about breaking down your software into smaller, independent parts and then about how to use synchronization primitives to coordinate them
- Dissect new data structures that exploit and draw performance out of multicores
- Design your own scalable data structures
- Study the tools to benchmark and debug these structures
Throughout the course, you will work on weekly -- but quite manageable
-- coding tasks. These exercises revolve around improving an initially
quite simplistic HTTP server written in C++. This kind of software is
easily parallelizable, presenting several opportunities for us to
apply the ideas seen in class. By the end of the course you would have
turned the server into quite a scalable piece of software.
Courant does have a cluster of multicore XEON machines
(energon{1-4}.cims). That is the platform we will be coding for.
Pre-Requisites
- Operating Systems
- Not be ashamed of coding; this is a hands-on course (in C/C++)
Mailing List
Please subscribe to the mailing list
g22_2631_001_sp10
and feel free to use it to send questions or comments.
Grading
- 10% Quizes
- 20% Project
- 35% Labs
- 35% Final Exam
Material
The class won't strictly follow any textbook but we will often refer
to the first book on this list. I listed other occasional support
texts that will be on reserve as well.
- "The Art of Multiprocessor Programming", by Herlihy and Shavit, Morgan Kaufmann, 2008.
- "Unix Networking Programming, The Sockets Networking APIs", by Stevens et al., 3rd Edition.
- "Computer Organization and Design, The Hardware / Software Interface", by Patterson and Hennessy, 4th edition.
- "Parallel Computer Architecture, A Hardware / Software Approach", by Culler, Signh, and Gupta.
- "The C++ Programming Language", by Stroustroup, Addison Wesley, 3rd Edition.