Shared-Variable Concurrency: A Proposal
In this talk I discuss the semantics of shared-variable concurrency, aka multi-threading. There are two well-known ways of managing concurrent threads: one either uses a preemptive or a cooperative scheduling discipline. In the former, a program, or more precisely its executable version, can be interrupted at any time during its execution by an external device, the scheduler, and the resources needed for execution are then given to another concurrent component for a while. This is perfect for executing concurrent processes, which do not share memory. In this case, the programmer does not have to care about the relative performance of the various processes in the system: this is the task of the scheduler. Unfortunately, it is very difficult to program multi-threaded applications with this model. The main difficulty is with data races, that is conflicting concurrent accesses to the memory. Although it is very easy to provide a formal “interleaving” semantics for preemptive multi-threading, this semantics usually does not coincide with what is actually implemented. In particular, the grain of atomicity is generally not preserved by the implementation, and a program may be time-sliced at some points of its execution which make no sense at the user level, and the consequence is that there is no clear semantics for the race conditions (see  for instance). It is therefore necessary to complement preemptive multi-threading with elaborate synchronization techniques, that require a real expertise from the programmer to be used (see ), and to design methods to analyze concurrent programs in order to make them “thread safe”, avoiding or detecting race conditions [1,6,11]. We shall not follow the preemptive approach in our proposal for shared-memory concurrency semantics.
KeywordsRecursive Call Concurrent Program Realizability Interpretation Data Race Concurrent Access
Unable to display preview. Download preview PDF.
- 1.Abadi, M., Flanagan, C., Freund, S.N.: Types for safe locking: static race detection for Java. In: ACM TOPLAS, vol. 28(2), pp. 207–255 (2006)Google Scholar
- 2.Barendregt, H.: Lambda Calculi with Types. In: Abramsky, S., Gabbay, D.M., Maibaum, T.S.E. (eds.) Handbook of Logic in Computer Science, vol. 2, pp. 117–309. Oxford University Press, Oxford (1992)Google Scholar
- 3.Birrel, A.D.: An introduction to programming with threads, SRC Report 35 (December 1989)Google Scholar
- 6.Grossman, D.: Type-safe multithreading in Cyclone. In: TLDI 2003, pp. 13–25 (2003)Google Scholar
- 9.Lucassen, J.M., Gifford, D.K.: Polymorphic effect systems. In: POPL 1988, pp. 47–57 (1988)Google Scholar
- 10.Mitchell, J.C.: Foundations for Programming Languages. MIT Press, Cambridge (1996)Google Scholar
- 12.Pitts, A., Stark, I.: Operational reasoning for functions with local state. In: Gordon, A., Pitts, A. (eds.) Higher- Order Operational Techniques in Semantics, Publications of the Newton Institute, pp. 227–273. Cambridge Univ. Press, Cambridge (1998)Google Scholar
- 13.Plotkin, G.: Lambda-definability and logical relations, Memo SAI-RM-4, University of Edinburgh (1973)Google Scholar
- 16.Tait, W.: A realizability interpretation of the theory of species, Logic Colloquium. Lecture Notes in Mathematics, vol. 453, pp. 240–251 (1975)Google Scholar