Analyzing stores and references in a parallel symbolic language

We describe an analysis of a parallel language in which processes communicate via first-class mutable shared locations. The sequential core of the language defines a higher-order strict functional language with list data structures. The parallel extensions permit processes and shared locations to be dynamically created; synchronization among processes occurs exclusively via shared locations. The analysis is defined by an abstract interpretation on this language. The interpretation is efficient and useful, facilitating a number of important optimizations related to synchronization, processor/thread mapping, and storage management.

[1]  Jyh-Herng Chow,et al.  Compile-time analysis of parallel programs that share memory , 1992, POPL '92.

[2]  Arvind,et al.  M-Structures: Extending a Parallel, Non-strict, Functional Language with State , 1991, FPCA.

[3]  D. H. Bartley,et al.  Revised4 report on the algorithmic language scheme , 1991, LIPO.

[4]  Olin Shivers.  The semantics of Scheme control-flow analysis , 1991 .

[5]  J. Gregory Morrisett,et al.  Adding threads to Standard ML , 1990 .

[6]  Andrew A. Chien,et al.  Experience with CST: programming and implementation , 1989, PLDI '89.

[7]  Williams Ludwell HarrisonIII.  The interprocedural analysis and automatic parallelization of Scheme programs , 1989 .

[8]  Takayasu Ito,et al.  Parallel Lisp: Languages and Systems , 1990, Lecture Notes in Computer Science.

[9]  Larry Rudolph,et al.  Basic Techniques for the Efficient Coordination of Very Large Numbers of Cooperating Sequential Processors , 1983, TOPL.

[10]  Olin Shivers,et al.  Data-flow analysis and type recovery in Scheme , 1990 .

[11]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

[12]  Suresh Jagannathan,et al.  A concurrent abstract interpreter , 1994, LISP Symb. Comput..

[13]  Andrew W. Appel,et al.  Compiling with Continuations , 1991 .

[14]  Jonathan Rees,et al.  T: a dialect of Lisp or LAMBDA: The ultimate software tool , 1982, LFP '82.

[15]  Craig Chambers,et al.  Iterative type analysis and extended message splitting; optimizing dynamically-typed object-oriented programs , 1990, PLDI '90.

[16]  Williams Ludwell Harrison,et al.  The interprocedural analysis and automatic parallelization of Scheme programs , 1990, LISP Symb. Comput..

[17]  Monica S. Lam,et al.  Coarse-grain parallel programming in Jade , 1991, PPOPP '91.

[18]  Nicolas Mercouroff,et al.  An Algorithm for Analyzing Communicating Processes , 1991, MFPS.

[19]  John H. Reppy,et al.  CML: A higher concurrent language , 1991, PLDI '91.

[20]  David K. Gifford,et al.  Polymorphic effect systems , 1988, POPL '88.

[21]  Saumya K. Debray,et al.  Static inference of modes and data dependencies in logic programs , 1989, TOPL.

[22]  Ehud Shapiro,et al.  Concurrent PROLOG: Collected Papers , 1987 .

[23]  John H. Reppy,et al.  CML: A Higher-Order Concurrent Language , 1991, PLDI.

[24]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[25]  Patrick Cousot,et al.  Semantic foundations of program analysis , 1981 .

[26]  Paul Hudak,et al.  Collecting interpretations of expressions , 1991, TOPL.

[27]  J. Gregory Morrisett,et al.  Procs and locks: a portable multiprocessing platform for standard ML of New Jersey , 1993, PPOPP '93.

[28]  Guy L. Steele,et al.  Making asynchronous parallelism safe for the world , 1989, POPL '90.

[29]  Paul Hudak,et al.  A collecting interpretation of expressions , 1988, POPL '88.

[30]  John M. Mellor-Crummey,et al.  On-the-fly detection of data races for programs with nested fork-join parallelism , 1991, Proceedings of the 1991 ACM/IEEE Conference on Supercomputing (Supercomputing '91).

[31]  C RinardMartin,et al.  Coarse-grain parallel programming in Jade , 1991 .

[32]  John McCarthy,et al.  Queue-based multi-processing LISP , 1984, LFP '84.

[33]  Paul Hudak,et al.  An Optimising Compiler for a Modern Functional Language , 1989, Comput. J..

[34]  Alain Deutsch,et al.  On determining lifetime and aliasing of dynamically allocated data in higher-order functional specifications , 1989, POPL '90.

[35]  Suresh Jagannathan,et al.  A foundation for an efficient multi-threaded scheme system , 1992, LFP '92.