IT-Universitetet i København
 
  Tilbage Kursusoversigt
Kursusbeskrivelse
Kursusnavn (dansk):Practical Concurrent and Parallel Programming 
Kursusnavn (engelsk):Practical Concurrent and Parallel Programming 
Semester:Efterår 2015 
Udbydes under:cand.it., softwareudvikling og -teknologi (sdt) 
Omfang i ECTS:7,50 
Kursussprog:Engelsk 
Kursushjemmeside:https://learnit.itu.dk 
Min. antal deltagere:
Forventet antal deltagere:60 
Maks. antal deltagere:100 
Formelle forudsætninger:Students must know the Java programming language very well, including inner classes and a first exposure to threads and locks, and event-based graphical user interfaces as in Swing or AWT. 
Læringsmål:After the course, the successful student can:

* ANALYSE the correctness of concurrent Java software, and RELATE it to the Java memory model
* ANALYSE the performance of concurrent Java software
* APPLY Java threads and related language features (locks, final and volatile fields) and libraries (concurrent collections) to CONSTRUCT correct and well-performing concurrent Java software
* USE software tools for accelerated testing and analysis of concurrency problems in Java software
* CONTRAST different communication mechanisms (shared mutable memory, transactional memory, message passing) 
Fagligt indhold:Please note, that due to technical challenges, changes may occur before the start of the semester (week 35) – this applies to all sections of the course description.

In this course you learn how to write correct and efficient concurrent and parallel software, primarily using Java, on standard shared-memory multicore hardware such as laptops, desktops and servers. The course covers basic mechanisms such as threads, locks and shared memory as well as more advanced mechanisms such as transactional memory, message passing, and lock-free data structures implemented using atomic compare-and-swap instructions. It covers concepts such as atomicity, safety, liveness and deadlock. It covers how to measure and understand performance and scalability of parallel programs. It covers tools and methods to find bugs in concurrent programs.

Topics covered include:

* Threads and locks in Java, shared mutable memory, mutual exclusion, atomic operations, avoiding sharing (thread confinement, stack confinement), designing thread-safe classes, the Java monitor pattern, object graph sharing.
* Visibility, volatile, immutable objects, final, the Java memory model.
* Performance and scalability, performance measurements, scalability case studies: concurrent hashmap, parallel quicksort.
* Tasks, the Java executor framework, concurrent pipelines, blocking queues.
* Concurrency and single-threaded GUI applications.
* Testing concurrent programs, correctness, safety and liveness concepts, deadlock, livelock, the ThreadSafe tool, the Java Pathfinder tool.
* Transactional memory, the Multiverse library.
* Optimistic concurrency, lock-free data structures, Treiber stack, compare-and-swap, the Michael and Scott queue, progress concepts, how to implement a lock.
* Message passing concurrency, concepts from Erlang, the Java Akka framework. 
Læringsaktiviteter:14 ugers undervisning bestående af forelæsninger og øvelser

Lectures, weekly exercises, mandatory hand-ins. 

Obligatoriske aktivititer:5 out of 6 bi-weekly mandatory hand-ins have to be approved as prerequisite for taking the exam. 
Eksamensform og -beskrivelse:X. experimental examination form (7-scale; external exam)

Written take-home exam (individual mini-project)
- Total duration 30 hours
- Expected exam workload 16 hours
- Individual
- Submission in LearnIT
- All materials, including Internet access, allowed
- Plagiarism or copying of solutions not allowed.
- No oral exam but a fraud check will be performed after the hand-in. 20 % of students randomly selected will have to meet at ITU (place and time will be publiced later) to check authorship.  

Litteratur udover forskningsartikler:* Goetz et al: Java Concurrency in Practice, Addison-Wesley 2006. Book homepage: http://jcip.net/
* Herlihy and Shavit: The Art of Multiprocessor Programming. Revised first edition, Morgan Kaufmann 2012. Chapters 1, 3, 18.1, 18.2.
* Sestoft: Microbenchmarks in Java and C#. Lecture notes, IT University of Copenhagen 2014.
* The Multiverse Software Transactional Memory library documentation.
* Armstrong, Virding, Williams: Concurrent Programming in Erlang. 
 
Undervisere
Følgende personer underviser på kurset:
NavnStillingUndervisertypeIndsats (%)
Claus Brabrand Lektor(ITU) Underviser 20
Peter Sestoft Sektionsleder(ITU) Kursusansvarlig 80
Florian Biermann Ph.d.-studerende(ITU) Underviser 0
Håkan Lane Undervisningsassistent(ITU) Underviser 0
Martin Rønning Bech Hjælpelærer(ITU) Hjælpelærer 0