Seminar on Parallel and Concurrent Programming
||Mi 13:45 - 15:15
||Room: S3 047
This is a seminar on research topics in the field of parallel and concurrent
programming. The goal of this seminar is to convey an overview of current
techniques as well as to practice basic research and presentation skills.
Course Language: English
Course Prerequisites: General Computer Science background.
No specific background in concurrency and parallelism is required.
2016-10-05: Added slides for introduction lecture.
The seminar starts out with two introductory lectures on parallel and
concurrent programming. Afterwards, each participant prepares a talk, an oral
paper review, and a report.
Each participant selects a paper from one of the following two categories:
- Cat1 - Research papers: papers presenting novel ideas relevant to one of
the seminar topics
- Cat2 - Research papers with artifact evaluation: papers with novel ideas
that come along with an artifact that has been evaluated and certified by a
conference artifact evaluation committee.
We will have weekly meetings during the semester in which we discuss two of
the papers. The discussion will be managed by the student to whom the paper was
assigned as the presenter. She/he gives a detailed presentation about the
insights of the paper (30 mins).
To facilitate scientific debate, a second
student will be assigned the role of paper reviewer. The paper reviewer prepares
questions about the paper (min. 5 insightful questions) to be asked after the
presentation. Students can volunteer for the role of "paper reviewer" if they
have an interest in a specific topic. Otherwise, the paper to review is the other
paper of the same seminar session.
In addition to presenting a paper, each student has to carry out one of the
following activities (depending on the category of the paper):
- Cat1: Write a summary of the paper (max 500 words) together with an overview
of the state of the art in the field (4000 words, excl. bibliography).
- Cat2: Write a summary of the paper (max 500 words), and perform experimental
work on the artifact described in the paper. For example, reproduce the
results discussed in the paper using different configurations and/or input
data sets. Write a short report on the experimental work, highlighting gained
insights in practical aspects of the technique, and possible limitations (2000
The summary of the paper (500 words) must be submitted two days before the
meeting (11:59 noon). They will be made available and will be used to drive the
discussion about the paper in the following meeting.
We offer consultations to prepare the talks and reports.
Consultations on preparing the talks are mandatory.
For alternative paper proposals as well as for category 2 reports,
consultations are mandatory to ensure that we agree on a specific topic.
- Slides for talk (30 mins), consultation 1 week before
- Paper overview/summary (500 words), 2 days before meeting (11:59 noon)
- Questions on reviewed paper (min. 5 questions, other paper of same session), 2 days before meeting (11:59 noon)
- Report (Cat. 1 or 2), deadline February 6th, 2017
The topics of this seminar cover programming language design, implementation,
and tooling aspects in the domain of parallel and concurrent programming.
The papers the participants can chose from are related to one of the
- High-level language concurrency models (conc-model)
- Actors, Communicating Sequential Processes, STM, Stream Processing, ...
- Tooling (tooling)
- Implementation and runtime systems (runtime)
- Communication mechanisms
- Data/object representation
- System-level aspects
- Big Data Frameworks (bigdata)
- Programming models
- Runtime level problems
The following list contains the proposed papers for the seminar.
Other papers can be proposed as well, but require our confirmation to ensure they
fit into the seminar.
Papers without Artifact
- P1.1: Transactional Data Structure Libraries, A. Spiegelman, G. Golan-Gueta, I. Keidar (conc-model, PLDI'16)
- P1.2: Type-Aware Transactions for Faster Concurrent Code, N. Herman, J. Priya Inala, Y. Huang, L. Tsai, E. Kohler, B. Liskov, L. Shrira (conc-model, runtime, EuroSys'16)
- P1.3: 43 Years of Actors: a Taxonomy of Actor Models and Their Key Properties, J. De Koster, T. Van Custem, W. De Meuter (conc-model, Agere'16)
- P1.4: Why Do Scala Developers Mix the Actor Model with other Concurrency Models?, S. Tasharofi, P. Dinges, R. Johnson (conc-model, ECOOP'13)
- P1.5: A Java Fork/Join Framework, D. Lea (conc-model, runtime, Java'00)
- P1.6: The Asynchronous Partitioned Global Address Space Model, V. Saraswat, G. Almasi, G. Bikshandi, C. Cascaval, D. Cunningham, D. Grove, S. Kodali, I. Peshansky, O. Tardieu (conc-model, AMP'10)
- P1.7: Pydron: Semi-Automatic Parallelization for Multi-Core and the Cloud, S. C. Müller, A. Csillaghy (conc-model, runtime, OSDI'15)
- P1.8: Fast Splittable Pseudorandom Number Generators, G. L. Steele, D. Lea, C. H. Flood (runtime, OOPSLA'14)
- P1.9: The Linux Scheduler: A Decade of Wasted Cores, J.-P. Lozi, B. Lepers, J. Funston, F. Gaud, V. Quéma, A. Fedorova (runtime, EuroSys'15)
- P1.10: Application-Assisted Live Migration of Virtual Machines with Java Applications, K.-Y. Hou, K. G. Shin, J.-L. Sung (runtime, EuroSys'15)
- P1.11: Distributed Debugging for Mobile Networks, E. Gonzalez Boix, C. Noguera, W. De Meuter (tooling, JSS'14)
Papers with Artifact
- P2.1: Optimistic Concurrency with OPTIK, R. Guerraoui, V. Trigonakis, [artifact] (conc-model, PPoPP'16)
- P2.2: Transactional Tasks: Parallelism in Software Transactions, J. Swalens, J. De Koster, W. De Meuter [artifact] (conc-model, ECOOP'16)
- P2.3: StreamJIT: a commensal compiler for high-performance stream programming, J. Bosboom, S. Rajadurai, W.-F. Wong, S. Amarasinghe, [artifact] (conc-model, runtime, OOPSLA'14)
- P2.4: An Efficient Synchronization Mechanism for Multi-core Systems, M. Aldinucci, M. Danelutto, P. Kilpatrick, M. Meneghin, M. Torquati, [artifact] (conc-model, runtime, EuroPar'12)
- P2.5: Parallel parsing made practical, A. Barenghi, S. C. Reghizzi, D. Mandrioli, F. Panella, M. Pradella, [artifact] (runtime, SCP'15)
- P2.6: SparkR : Scaling R Program with Spark, S. Venkataraman et al., [artifact1] [artifact2] (conc-model, bigdata, SIGMOD'16)
- P2.7: SparkSQL: Relational Data Processing in Spark, M. Armbrust et al., [artifact] (bigdata, runtime, VLDB'14)
- P2.8: Twitter Heron: Stream Processing at Scale, S. Kulkarni et al., [artifact] (bigdata, SIGMOD'15)
- P2.9: OCTET: Capturing and Controlling Cross-Thread Dependences Efficiently, M. D. Bond, M. Kulkarni, M. Cao, M. Zhang, M. F. Salmi, S. Biswas, A. Sengupta, J. Huang, [artifact] (tooling, OOPSLA'13)
- P2.10: Efficient and Thread-Safe Objects for Dynamically-Typed Languages, B. Daloze, S. Marr, D. Bonetta, H. Mössenböck, [artifact available internally, to be published] (runtime, OOPSLA'16)
- W1: Seminar Introduction, and an Overview of Contemporary Concurrent Programming Approaches
- W2: Parallel Programming Challenges and Research Directions
- approx. W3-W6: no seminar, preparation time for participants, and consultations
- approx. W7-W12: 2 presentations per meeting
Note, the paper to review and prepare questions for is the other paper in the same session.
- W07: Thread-based Concurrency (November, 30th)
P1.9: The Linux Scheduler: A Decade of Wasted Cores, J.-P. Lozi, B. Lepers, J. Funston, F. Gaud, V. Quéma, A. Fedorova
P2.9: OCTET: Capturing and Controlling Cross-Thread Dependences Efficiently, M. D. Bond, M. Kulkarni, M. Cao, M. Zhang, M. F. Salmi, S. Biswas, A. Sengupta, J. Huang
- W08: Fork/Join Parallelism (December, 7th)
P1.5: A Java Fork/Join Framework, D. Lea
P*: Work-Stealing Without The Baggage, V. Kumar, D. Frampton, S. M. Blackburn, D. Grove, O. Tardieu
- W09: Runtime Support for Concurrent Systems (December, 14th)
P1.2: Type-Aware Transactions for Faster Concurrent Code, N. Herman, J. Priya Inala, Y. Huang, L. Tsai, E. Kohler, B. Liskov, L. Shrira
Efficient and Thread-Safe Objects for Dynamically-Typed Languages, B. Daloze, S. Marr, D. Bonetta, H. Mössenböck
- W10: Data Structure Design and Compilers for Parallelism (January, 11th)
P1.8: Fast Splittable Pseudorandom Number Generators, G. L. Steele, D. Lea, C. H. Flood
P2.3: StreamJIT: a commensal compiler for high-performance stream programming, J. Bosboom, S. Rajadurai, W.-F. Wong, S. Amarasinghe
- W11: Actor-based Concurrency (January, 18th)
P1.3: 43 Years of Actors: a Taxonomy of Actor Models and Their Key Properties, J. De Koster, T. Van Custem, W. De Meuter
Distributed Debugging for Mobile Networks, E. Gonzalez Boix, C. Noguera, W. De Meuter
- W12: Automatic Parallelization (January, 25th)
P2.5: Parallel parsing made practical, A. Barenghi, S. C. Reghizzi, D. Mandrioli, F. Panella, M. Pradella
P1.7: Pydron: Semi-Automatic Parallelization for Multi-Core and the Cloud, S. C. Müller, A. Csillaghy
Teaching Goals/Learning Objectives
- Subject Specific
- an overview of the concurrent and parallel programming techniques
- detailed understanding on a specific topic of the student’s choice
- training of basic research skills, understanding and reporting on scientific work
- training of basic presentation skills and scientific debating
Grading and Evaluation
For passing this seminar, students are required to attend 80% of all meetings.
- 50% slides, presentation, and discussion
- 50% writeup/experiments
For students that have a strong interest in the discussed topics,
follow-up projects (e.g., a master thesis) are available.
The work for this seminar can be considered the starting point for such
The first lecture gives an overview of the seminar, and a high-level introduction
to different concurrent programming models.