This page collects information about the proposed "Multicore Programming" MSc programme.
Advanced Java for Programmers
(option from any MSc)
Project Research > project preparation
Concurrency and Parallelism
Parallel Programming with Shared Memory
Parallel Programming with Message-Passing
Existing modules common to all taught MSc programmes:
The new modules are:
C++ Programming (FRMB)
There's more of this on the individual module pages above; these are the general points.
The caretakers need to start writing module specifications now; PGK needs these by 11 May but we should try to get these done earlier so they can be circulated for comment.
- Module specifications do not need to be perfect, but good enough to go through the QA process; they can always be modified later.
- Planning to start in September 2010.
- Significant overlap with Advanced Software Development MSc and Molecular Computation MSc.
- Aim to attract overseas students -- so needs to handle widely-varying qualifications, and allow students to study English in parallel.
- This is a fast-moving research area.
- Get students to engage with research; for example, by integrating seminars in which material is discussed into the modules.
- Keep the learning outcomes general enough that we can adjust the actual material on a year-by-year basis.
- Lots of opportunities for industrial involvement.
- Teaching material and software from Intel, AMD, NVidia, XMOS, etc.
- Kit -- we need several different systems for students to try out parallel software on.
- Industrial placements programme
- Industrial projects too? (Probably not necessary to have both.)
- The module names need to be meaningful to students; we'll probably want to tweak those above.
- We could offer options for more specific applications -- e.g. games programming or scientific computing -- in the future.
Here are the comments from Prof Robert Berry (Aston, formerly IBM and Visiting Prof at Kent)
Robert Berry writes...
1. Potential market for the programme
I think it is modest but growing. Multicore has emerged as the way to scale our processing power given physical constraints in scaling up single processor speeds. Visibility of multicore systems is growing through systems like PS3’s use of Cell, and this will also drive interest.
2. Curriculum content of the programme
Looks very good. Focus up front on core concepts is entirely appropriate before launching into programming for this environment. I wonder if doing Java and C++ is the best choice. This is a tough call – but C++ might be more appropriate for this type of environment … also could provide opportunity for more focus; … or perhaps C# with its stronger support for memory management. (Perhaps Realtime Java, but that’s a bit of an abomination.).
3. Does the programme content articulation/progression in an appropriate manner and at the correct level?
I’m unclear about incoming expectations. What are the prerequisites for people taking the course? Are C++ and Java delivered as if new? (there’s a comment in the conc+parallelism module that suggests this: “…students will be learning java/c++ at the same time …”. Might be asking a lot, and indeed might constrain rest of cohort if people aren’t already to a certain level of skill. A core competence in one or both languages seems to make sense as a prereq. What you’re really doing here is adding the (very complex!) parallel dimension.
Unclear as to whether the two first modules – concurrency and parallelism; and parallel architectures actually involve programming. Not sure they need to – but each module description has an identical section 18 that implies there will be. If programming is required, how will you stagger the teaching of the programming (java first, then c++) with the assessment approach for these two modules. Comes back to earlier question really on prerequisites.
4. Any other areas of note considered appropriate by the external advisor
Java and Multicore might be a difficult mix. I don’t know if Java has yet been (well) ported to exploit multicore systems; the burden probably falls more to the programmer.
In resources you don't mention the Cell development kit(s?); I know IBM put a number of such things out on Developerworks, and these have been well used in other institutions (e.g., Imperial). And of course, they apply to a technology that many students may have at home in their PS3s.
1. Noted, though we are not sure what the long term future of the Cell processor is. However, there are a number of other interesting new architectures emerging including those in the GPGPU market as well as more conventional x86 multicores from Intel. We also have support from Sun Microsystems for this programme. Katherine Hartsell, responsible for Sun's Teaching Concurrent Computing Initiative, writes that she would "like to submit a request to our OpenSPARC group that Kent be added, and that we send you a CMT machine."
2 and 4. There are several reasons why we wish to teach the advanced Java course to the experienced programmers that this program seeks to recruit. First, it acts as a "service" module, making other options from the MSc portfolio accessible to students on this program. Second, Java permits early introduction to notions of concurrency through the JCSP library which can be used to demonstrate message-passing, some (lock-free) shared-memory and data-parallel models in the first term before exposing students to more difficult, lower level algorithms expressed through a threads and locks model. We agree with your view of the Real-Time Specification for Java (though we note the emergence of real-time JVMs that do not rely on RTSJ).
We have chosen to teach C++ for many of the reasons you have suggested (e.g. for OpenMP, TBB etc). We believe that the step from Java to sufficient C++ for the purposes of this programme should not be too great.
3. The programme spec states that entrants must have have a "first degree in CS or a closely related subject with a substantial coverage of programming and SE". The CO871 Advanced Java for Programmers is not an introductory course: students must have substantial prior programming experience. In practice, we have found that for most students their prior experience is Java; for a smaller minority it is either C++ or C# but in both cases the transition to Java is straightforward. Thus, effectively, as Prof Berry suggests, a core competence in one or both of Java and C++ is assumed.
We expect both the Concurrency & Parallelism module and Parallel Architectures module to contain some practical experience. We anticipate that any programming would be in Java. CO871 is delivered as a semi-intensive course in the first 6 weeks of the programme. Thus students' prior programming experience should be sufficient for exercises early in these two modules, and they will have completed CO871 in time for the latter half of these two modules.
4. Thank you for the pointer to the use of Cell development kits for teaching. The research group responsible for this proposal has used these for programming language implementation but it is useful to know that other institutions have used these for teaching.
Comments from Sun
Dave Dice via Tony Printezis has provided some really useful feedback:
Generally it looks like a fine course layout and is similar in form to other's that I've seen. I appreciate the general philosophy of not poisoning the student's minds with threads & locks too early.
- C++ Programming : I only glanced at this briefly, but it looks perfectly acceptable.
Concurrency & Parallelism :
- Doug Lea's CPiJ book is generally being supplanted by Goetz et al. CJiP, which, while useful for less sophisticated practitioners needs to be augmented with a good dose of theory and awareness of the Java editorial bent. (Oops, I see you call out the Goetz book in later modules).
One concern about Herlihy&Shavit is that while it's very current and well-written (beware: I'm biased of course) is that the use of Java deftly avoids certain interesting synchronization issues that will be confronted by programmers in C/C++. For instance many of the algorithms depend on recycling memory through GC and nicely avoids ABA problems. If you transliterate the algorithms to C or C++ you'll find they're broken.
- Parallel Architectures :
- It might be useful to consider adding something to the topic list about consistency and platform memory models. This is something that we struggle with regularly in the real world. It also ties in nicely to the new C++0x extensions, java "volatile" etc.
- Regarding reference materials, Culler/Singh/Gupta "Parallel Computing Architectures" is somewhat long in the tooth, but still one of the best books around.
- Parallel programming with shared memory :
- Lock-free techniques?
In additional to Intel's C/C++ STM, Sun may have a C compiler with STM support available late this calendar year. (That's our hope, anyway). That gives you one more option. The STM runtime library for the Sun environment should be made open-source in the next week or so. The general consensus is that you'd be better served finding something other than DSTM2. In the Java space there are projects like Multiverse and Deuce that use bytecode rewriting to provide STM capabilities, but at this point in time they're probably not sufficiently mature to use in a course. (But perhaps you could test with the waters with a student project).
- I recognize that you're reluctant to inflict new languages on your students, but Clojure, like Haskell, has a built in STM that's easy to use.
- Parallel processing with message passing :
- Microsoft's Axum might make an interesting alternative to Erlang. Axum has a civilized syntax, but there are quite a few books and resources and in the Erlang community.
The existing MSc portfolio programme specification, which contains the common learning outcomes that modules need to reference
PGK says: "A small number of new LOs may be added for each new programme. Any new ones would be in parts A or C. [...] [Module learning outcomes should have a strong] emphasis on advanced knowledge and intellectual skills."
OpenSPARC Sharing Teaching Material for Concurrent Computing lots of links to courses around the world
U. Karlsruhe's Multicore systems group has a teaching page.
Intel Academic Community has resources for teaching multicore (teaching material, software)
Intel Ct language/system/??
Intel Parallelism 2009 Adam's notes on Intel's "Parallelism Faculty 3.0" training course at Birmingham City University in November 2009