Address
Jakob-Haringer-Str. 2
5020 Salzburg, Austria
Room 2.17
Phone
+43 (0)662 8044 6417
+43 (0)662 8044 611 (fax)
Skype ana_sokolova
Address
Jakob-Haringer-Str. 2
5020 Salzburg, Austria
Room 2.17
Phone
+43 (0)662 8044 6417
+43 (0)662 8044 611 (fax)
Skype ana_sokolova
Many thanks to Silviu Craciunas for the photo (RTAS 2010 in Stockholm) and his help with iWeb!
Introduction to Concurrency Theory and Practice
Summer semester 2018/2019 together with Christoph Kirsch
Schedule: Mondays 11am-12noon, Tuesdays 1:30pm-3pm in T06
see calendar (newest schedule after the Easter break)
First meeting: Tuesday, March 5 at 10pm in T04 (only the first week at 10am)
Language: English
The course may also be taken by PhD students
Literature:
•General Textbook: The Art of Multiprocessor Programming, by Maurice Herlihy and Nir Shavit.
This book can serve as background information for some of the topics that we cover.
A list of papers will be added here, as we proceed with the course.
Prerequisites: No particular knowledge is expected that is beyond the bachelor study. You may need some basic notions of systems and theory, as well as programming in C++ for parts of the course.
Exam: This is a 2VO+1PS course. For the lectures part (VO), there will be three exam possibilities in June/July/August. The exam is written consisting of several questions / excersises from the material covered during the course. For the practical part (PS), there will be mini projects.
In addition, we may give homework in class from time to time. This is to help you estimate your progress, and possibly provide you with feedback (if you hand in the homework for corrections). It is not obligatory to hand in homework.
Exam dates: The first exam possibility is July 18 at 3pm in T04. We will have additional dates if needed -- one in August and one in October.
Mini projects: We have scheduled presentations on Thursday, July 4 at 3pm (for at most 1.5 hours) and Thursday, July 25 at 3pm (for at most 2.5 hours).
Schedule:
•Week 1, Tuesday 5.3.19, Introduction, discussion, planning -- a first meeting. We also already learned the basics of the semantics of concurrent objects, as well as the problems of interest in terms of performance and semantics, using overview tutorial slides. Next time we will go into more details.
•Week 2, Tuesday 12.3.19, Basic definitions, sequential specifications -- inductive and axiomatic (aspect-based) characterisations of the sequential specifications of stack, queue, and pool. I sent you my lecture notes via the ICTP Slack channel.
•(No class on Tuesday 19.3.19 due to traveling.)
•Week 3, Tuesday 26.3.19, more interesting properties of sequential specification and examples of specifications of data structures; basics needed for defining concurrent histories and behaviours as well as linearizability. I sent you my lecture notes via the ICTP Slack channel.
•Week 4, Tuesday 2.4.19, we learned about quantitatively relaxed concurrent data structures -- in particular relaxing the sequential specification in a quantitatively controlled way. Basically we followed the details of this paper, while proving also all simple properties and clarifying additional things. In the beginning we started with a high-level overview, given by these slides. Here is also a version of the slides with each stage of builds. I also already sent you my lecture notes in the slack channel.
•Week 5, Tuesday 9.4.19, we continued discussing quantitatively relaxed concurrent data structures -- with lot of details, proofs and examples. I already sent you my lecture notes in the slack channel.
All classes in the first 5 weeks were taught by myself. We changed the schedule after the Easter break to Monday 11:15am-12noon and Tuesday 1:30-3 pm, always in T06.
•Week 6, Monday 6.5.19 and Tuesday 7.5.19. The classes were taught by Christoph Kirsch. We discussed the layout of the machine that affects performance of concurrent programs: architecture, memory, caches, ... This part was a summary and repetition of basic systems facts related to programming concurrent programs, and particular facts about the architecture of our many-core machines. The students received simple programming homeworks that aim at creating worst-case performance scenarions.
Due to absence / illness of Christoph Kirsch, all the following classes were taught by myself (and some classes were cancelled when I was traveling).
•Week 7, Monday 13.5.19 and Tuesday 14.5.19. We returned to the discussion of consistency conditions, linearizability, sequential consistency, and started also with an overview presentation of local linearizability. We used the following slides. Here is also a version of the slides with each stage of builds.
•Week 8, Monday 20.5.19 and Tuesday 21.5.19. We discussed local linearizability in detail, with carefully stating all definitions and proving some important properties (like compositionality). Related to this, we also discussed compositionality in general and presented the nice proof of Herlihy&Wing for linearizability, as well the well-known example of sequential consistency not being compositional. I am sending you my notes from this and the previous week in the slack channel.
•Week 9, (no class on Monday due to a meeting) Tuesday 28.5.19. We discussed the algorithms of many concurrent data structures, starting from the Michael-Scott queue and Treiber stack, to the relaxed versions: k-FIFO and k-Stack, distributed queues in different load-balancing scenarios, as well as the scheme of designing locally-linearizable implementations.
•(no class on Monday 3.6.19 and Tuesday 4.6.19 due to traveling)
•(no class on Monday 10.6.19 and Tuesday 11.6.19 due to public holidays)
•Week 10, all on Tuesday 18.6.19 12:30-3pm (with no break). We discussed three different topics here: (1) a “detailed” hand-written proof of linearizability of the k-Stack using linearization points; (2) time-stamped stack and its correctness; and (3) axiomatic theorems for proving linearizability via order extensions. For (2) we used the following slides from Andreas Haas. For (3) we used the following slides presenting a glimpse into unpublished work and some open problems -- here are also the slides with each stage of builds. With this, we wrapped up the course.
•(no class on Monday 24.6.19 and Tuesday 25.6.19 due to traveling)
Course description: This is a course on Semantics of Concurrent Programs. We will cover both theoretical aspects -- ways of defining semantics, some reasoning about correctness; and practical aspects -- concurrent programing and in particular programming concurrent data structures.
Our group has made significant contributions on efficient scalable data structures in the last decade, we have gathered a large body of knowledge as well as implemented a benchmarking environment and data structure implementations that are very much worth exploring, enhancing, and further studying.
The aim of this course is to introduce the existing area of concurrency to Master (or PhD) students that might be interested in either getting acquainted with programming concurrent objects, or even exploring related research topics in concurrency theory or concurrency in practice.
The student will implement small concurrent objects -- especially in the exercise part of the course -- and/or experiment with these or existing implementations that are part of our evaluation framework.
Ana Sokolova
Dr. TU Eindhoven, The Netherlands, 2005
Associate Professor
Department of Computer Sciences
Austria