(2010, fall semester)
Computer
science is currently undergoing a radical change from sequential to parallel
computing. This change is forced by fundamental laws of physics that limit
further performance gains from traditional uni-processor
architectures. In the future, increasing the performance of computer systems
will only be possible by using multicore parallelism.
Computing platforms of the future will have hundreds or even thousands of
processor cores available for parallel processing. Unfortunately very few
engineers know how to program multicore systems yet.
The ability to harness the raw computing power provided by massively parallel
systems will be a key qualification for tomorrow¡¯s software engineers. Already
today leading manufacturers such as IBM and Intel are offering parallel
processors on a chip. These architectures are quickly adopted in all major
computing areas, e.g., with PCs, gaming consoles, mobile devices and
high-performance computers.
This
course will serve as an introductory course to parallel programming (¡°Parallel
Programming Practice¡±). In the lectures we will discuss parallel programming
concepts. Our step-by-step approach starts with sequential programs and
gradually introduces parallel programming techniques as we move along.
A
series of individual programming assignments will highlight the concepts from
the lectures. They will allow students to experiment and become fluent with
parallel programming on multicore architectures. The software-development process
of deriving software design, implementation and tests from a given requirement specification will be trained.
The
term project gives students the opportunity to design and implement a software
project of their own choice. Students will use the cutting-edge Sony Playstation 3
development
platform for this course. At the end of the course, students will have a knowledge of
¡¤
the fundamental design philosophies of multicore architectures,
¡¤
software engineering design principles for
parallel programs, and
¡¤
parallel programming models and
emerging best practices.
A
brief outline of the history of computer architectures will discuss the current shift
to multicore architectures. A step-by-step approach
will provide the knowledge and skill-set needed to design and develop
applications for multicore architectures. Programming models for stream-based computing, task-parallelism and
data-parallelism will be discussed. Software design patterns for parallel
programs will be applied in a series of individual programming assignments and
in the group term project. Students will become familiar with the IBM Cell processor,
which is used in the Sony Playstation
3
and many emerging high-performance computers.
Parallel
programs are most efficient when they utilize the underlying hardware
effectively. Therefore this course is related to parallel computer
architectures, especially to the IBM Cell processor and to Intel
multicores. Programming languages shall allow the
programmer to express the parallelism inherent in an application in a natural
way. Programming languages and their
implementations through compilers and run-time systems are therefore closely
related to this course. Our pattern-based approach to parallel programming is related to software
engineering design patterns.
Lecturer: Dr.
Bernd Burgstaller (bburg at cs
dot yonsei dot ac dot kr)
TAs: You-sun
Ko (smails2098 at gmail dot com)
Calvin
Lin, Lawrence Snyder, Principles of Parallel Programming, Addison
Wesley; 1st edition, 2008.
Timothy
G. Mattson, Beverly A. Sanders, Berna L. Massingill, Patterns
for Parallel Programming, Addison Wesley, 3rd printing, 2007.
Maurice Herlihy, Nir Shavit, The
Art of Multiprocessor Programming, Morgan Kaufmann, 2008.
Matthew Scarpino, Programming
the Cell Processor: for Games, Graphics, and Computation, Prentice Hall,
2009.
Various online resources on the IBM Cell processor and
its programming models and techniques.
Individual programming assignments should be turned in before or at the due date before midnight. When turned in late, 5% will be deducted from the grade per day until the assignment has been received, with a maximum extension of five days.
Where appropriate, students will be provided with a representative set of testcases, but not all testcases used for grading will be made public. Students are encouraged to create their own testcases, to ensure that an implementation works correctly. Creating good test cases is part of the learning process of this course.
Assignments will be marked by automated test scripts. Students must ensure that their solutions work in the lab environment (server and/or playstations). Only solutions that can be compiled, do not crash or enter an "endless" loop, and produce meaningful output can receive points. If a solution works correctly for all test cases, it will receive maximum points.
|
Week |
Lecture |
|
1 |
Admin, Introduction to
Parallel Programming |
|
2 |
Parallelism |
|
3 |
Programming with Pthreads |
|
4 |
Thread communication &
synchronization |
|
5 |
Performance of parallel
programs |
|
6 |
Parallel hardware
architectures |
|
7 |
Programming the Cell BE
architecture |
|
8 |
Midterm exam |
|
9 |
Parallel programming design
patterns |
|
10 |
High-level programming
libraries |
|
11 |
The StreamIt
language for stream parallelism |
|
12 |
|
|
13 |
Debugging, performance
monitoring and optimizations |
|
14 |
Parallel programming future
trends |
|
15 |
Term project presentations |
|
16 |
Final exam |
We will offer tutorials on
several topics that are pre-requisites and that should help interested students
to get up to speed quickly. The first tutorial will introduce Linux and the
Linux programming environment (remote access via ssh,
editors, compilers, ...). Other tutorials will be
announced later. Tutorials will be held in addition to the course lectures.
Attendance of tutorials is voluntarily.