Abstract
This paper presents a new structure analysis technique handling references and dynamic structures which enables precise analysis of infinite recursive data structures. The precise analysis depends on an enhancement of Chase et al.'s Storage Shape Graph (SSG) called the Abstract Storage Graph (ASG) which extends SSG's with choice nodes, identity paths, and specialized storage nodes and references. These extensions allow ASG's to precisely describe singly- and multiply-linked lists as well as a number of other pointer structures such as octrees, and to analyze programs which manipulate them.
We describe program analysis to produce the ASG, and focus on the key operations: the transfer functions, summarization and deconstruction. Summarization compresses the ASG in such a way as to capture critical interdependencies between references. Deconstruction uses this information, stored by identity paths and refined references and nodes, to retrieve individual nodes for strong updates.
The research described in this paper was supported in part by National Science Foundation grant CCR-9209336, Office of Naval Research grant N00014-92-J-1961, and National Aeronautics and Space Administration grant NAG 1-613.
This is a preview of subscription content, log in via an institution to check access.
Preview
Unable to display preview. Download preview PDF.
References
A. V. Aho, R. Sethi, and J. D. Ullman. Compilers: Principles, Techniques and Tools. Computer Science. Addison-Wesley, Reading, Massachusetts, 1987.
Jong-Deok Choi, Michael Burke, and Paul Cariai. Efficient flow-sensative interprocedural computation of pointer-induced aliases and side effects. In Twentieth Symposium on Principles of Programming Languages, pages 232–245. ACM SIGPLAN, 1993.
A. A. Chien and W. J. Dally. Concurrent Aggregates (CA). In Proceedings of Second Symposium on Principles and Practice of Parallel Programming. ACM, March 1990.
A. A. Chien, W. Feng, V. Karaincheti, and J. Plevyak. Techniques for efficient execution of fine-grained concurrent programs. In Proceedings of the Fifth Workshop on Compilers and Languages for Parallel Computing, pages 103–13, New Haven, Connecticut, 1992. YALEU/DCS/RR-915, Springer-Verlag Lecture Notes in Computer Science, 1993.
R. Cytron, J. Ferrante, B. Rosen, M. Wegman, and F. Zadeck. An efficient method of computing static single assignment form and the control dependence graph. ACM Transactions on Programming Languages and Systems, 13(4):451–490, October 1991.
Andrew Chien, Vijay Karaincheti, and John Plevyak. The concert system — compiler and runtime support for efficient fine-grained concurrent object-oriented programs. Technical Report UIUCDCS-R-93-1815, Department of Computer Science, University of Illinois, Urbana, Illinois, June 1993.
D. Chase, M. Wegman, and F. Zadeck. Analysis of pointers and structures. In Proceedings of SIGPLAN Conference on Programming Language Design and Implementation, pages 296–310, June 1990.
L. Hendren and A. Nicolau. Parallelizing programs with recursive data structures. IEEE Transactions on Parallel and Distributed Systems, 1(1):35–47, January 1990.
L. Hendren, A. Nicolau, and J. Hummel. Abstractions for recursive pointer data structures: Improving the analysis and transformation of imperative programs. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation, pages 249–260. ACM SIGPLAN, ACM Press, June 1992.
S. Horwitz, P. Pfeiffer, and T. Reps. Dependence analysis for pointer variables. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation, pages 28–40. ACM SIGPLAN, ACM Press, 1989.
N. Jones and S. Muchnick. Flow analysis and optimization of lisp-like structures. In S. Muchnick and N. Jones, editors, Program Flow Analysis: Theory and Applications, pages 102–131. Prentice-Hall, 1981.
Vijay Karaincheti and Andrew Chien. Concert — efficient runtime support for concurrent object-oriented programming languages on stock hardware. In Proceedings of Supercomputing'93, 1993.
James Richard Larus. Restructuring symbolic programs for concurrent execution on multiprocessors. Technical Report UCB/CSD 89/502, University of California at Berkeley, 1989.
J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. In SIGPLAN Conference on Programming Language Design and Implementation, pages 21–33. ACM, June 1988.
E. Myers. A precise interprocedural data flow algorithm. In Eighth Symposium on Principles of Programming Languages, pages 219–30, 1981.
Author information
Authors and Affiliations
Editor information
Rights and permissions
Copyright information
© 1994 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Plevyak, J., Chien, A.A., Karamcheti, V. (1994). Analysis of dynamic structures for efficient parallel execution. In: Banerjee, U., Gelernter, D., Nicolau, A., Padua, D. (eds) Languages and Compilers for Parallel Computing. LCPC 1993. Lecture Notes in Computer Science, vol 768. Springer, Berlin, Heidelberg. https://doi.org/10.1007/3-540-57659-2_3
Download citation
DOI: https://doi.org/10.1007/3-540-57659-2_3
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-57659-4
Online ISBN: 978-3-540-48308-3
eBook Packages: Springer Book Archive