Fine‐grain concurrency

I have been interested in concurrent programming since about 1963, when its associated problems contributed to the failure of the largest software project that I have managed. When I moved to an academic career in 1968, I hoped that I could find a solution to the problems by my research. Quite quickly I decided to concentrate on coarse‐grained concurrency, that does not allow concurrent processes to share main memory. The only interaction between processes is confined to explicit input and output commands. This simplification led eventually to the exploration of the theory of Communicating Sequential Processes. Since joining Microsoft Research in 1999, I have plucked up courage at last to look at fine‐grain concurrency, involving threads that interleave their access to main memory at the fine granularity of single instruction execution. By combining the merits of a number of different theories of concurrency, one can paint a relatively simple picture of a theory for the correct design of concurrent systems. Indeed, pictures are a great help in conveying the basic understanding. This paper presents some on‐going directions of research that I have been pursuing with colleagues in Cambridge—both at Microsoft Research and in the University Computing Laboratory. Copyright © 2007 C.A.R. Hoare.

[1]  Peter Radford,et al.  Petri Net Theory and the Modeling of Systems , 1982 .

[2]  Mark Homewood,et al.  The IMS T800 Transputer , 1987, IEEE Micro.

[3]  K. Mani Chandy,et al.  Proofs of Networks of Processes , 1981, IEEE Transactions on Software Engineering.

[4]  Peter W. O'Hearn,et al.  Separation Logic Semantics for Communicating Processes , 2008, FICS.

[5]  John Tang Boyland,et al.  Checking Interference with Fractional Permissions , 2003, SAS.

[6]  Stephen D. Brookes,et al.  A Semantics for Concurrent Separation Logic , 2004, CONCUR.

[7]  Tadao Murata,et al.  Petri nets: Properties, analysis and applications , 1989, Proc. IEEE.

[8]  Jeffrey D. Ullman,et al.  Formal languages and their relation to automata , 1969, Addison-Wesley series in computer science and information processing.

[9]  C. A. R. Hoare Verification of Fine-grain Concurrent Programs , 2008, Electron. Notes Theor. Comput. Sci..

[10]  Robin Milner,et al.  Communicating and mobile systems - the Pi-calculus , 1999 .

[11]  Robert W. Floyd,et al.  Assigning Meanings to Programs , 1993 .

[12]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[13]  Cliff B. Jones,et al.  Specification and Design of (Parallel) Programs , 1983, IFIP Congress.

[14]  Cliff B. Jones,et al.  Tentative steps toward a development method for interfering programs , 1983, TOPL.

[15]  Cliff B. Jones,et al.  An Approach to Splitting Atoms Safely: Extended Abstract , 2006, MFPS.

[16]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[17]  C. A. R. Hoare Fine-Grain Concurrency , 2007, LASER Summer School.

[18]  John C. Reynolds,et al.  Separation logic: a logic for shared mutable data structures , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[19]  Andrew William Roscoe,et al.  The Theory and Practice of Concurrency , 1997 .

[20]  Robert W. Floyd,et al.  The Syntax of Programming Languages-A Survey , 1964, IEEE Trans. Electron. Comput..