Pointer Analysis for Structured Parallel Programs

ACM Transactions on Programming Languages and Systems

Volumn 25, Issue 1, 2003, Pages 70-116

  Rugina, Radu ^a   Rinard, Martin C ^b  

^a Department of Computer Science and School of Operations Research and Information Engineering   (United States)

^b MASSACHUSETTS INSTITUTE OF TECHNOLOGY   (United States)

Author keywords

Pointer analysis

Indexed keywords

MULTITHREAD PROGRAMS; PARALLEL LANGUAGES;

ALGORITHMS; APPROXIMATION THEORY; COMPUTER PROGRAMMING LANGUAGES; RECURSIVE FUNCTIONS; SEMANTICS; STORAGE ALLOCATION (COMPUTER);

STRUCTURED PROGRAMMING;

EID: 0346271722     PISSN: 01640925     EISSN: None     Source Type: Journal    
DOI: 10.1145/596980.596982     Document Type: Article

References (91)

1. ALDRICH, J., CHAMBERS, C., SIRER, E., AND EGGERS, S. 1999. Static analyses for eliminating unnecessary synchronization from Java programs. In Proceedings of the 6th International Static Analysis Symposium.
2. ANDERSEN, L. O. 1994. Program analysis and specialization for the C programming language. Ph.D. thesis, DIKU, University of Copenhagen.
3. BABB, J., RINARD, M., MORITZ, A., LEE, W., FRANK, M., BAHUA, R., AND AMARASINGHE, S. 1999. Parallelizing applications into silicon. In Proceedings of the IEEE Workshop on FPGAs for Custom Computing Machines, Napa Valley, CA.
4. BALASUNDARAM, V. AND KENNEDY, K. 1989. Compile-time detection of race conditions in a parallel program. In Proceedings of the 1989 ACM International Conference on Supercomputing, Crete, Greece.
5. BAHUA, R., LEE, W., AMARASINGHE, S., AND AGARWAL, A. 1999. Maps: A compiler-managed memory system for Raw machines. In Proceedings of the 26th International Symposium on Computer Architecture, Atlanta, GA.
6. BLANCHET, B. 1999. Escape analysis for object oriented languages. Application to Java. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO.
7. BLIEBERGER, J., BURGSTALLER, B., AND SCHOLZ, B. 2000. Symbolic dataflow analysis for detecting deadlocks in Ada tasking programs. In Proceedings of the 5th International Conference on Reliable Software Technologies Ada-Europe 2000.
8. BOGDA, J. AND HOELZLE, U. 1999. Removing unnecessary synchronization in Java. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO.
9. BOGLE, P. AND LISKOV, B. 1994. Reducing cross-domain call overhead using batched futures. In Proceedings of the 9th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Portland, OR.
10. BOYAPATI, C. AND RINARD, M. 2001. A parameterized type system for race-free Java programs. In Proceedings of the 16th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Tampa Bay, FL.
11. BUDIU, M., GOLDSTEIN, S., SAKE, M., AND WALKER, K. 2000. BitValue inference: Detecting and exploiting narrow bitwidth computations. In Proceedings of the EuroPar 2000 European Conference on Parallel Computing, Munich, Germany.
12. CALLAHAN, D., KENNEDY, K., AND SUBHLOK, J. 1990. Analysis of event synchronization in a parallel programming tool. In Proceedings of the 2nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Seattle, WA.
13. CALLAHAN, D. AND SUBHLOK, J. 1988. Static analysis of low-level synchronization. In Proceedings of the ACM SIGPLAN and SIGOPS Workshop on Parallel and Distributed Debugging, Madison, WI.
14. CARLISLE, M. AND ROGERS, A. 1995. Software caching and computation migration in Olden. In Proceedings of the 6th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Santa Barbara, CA, 29-38.
15. CHASE, D., WEGMAN, M., AND ZADEK, F. 1990. Analysis of pointers and structures. In Proceedings of the SIGPLAN '90 Conference on Program Language Design and Implementation, White Plains, NY.
16. CHENG, G., FENG, M., LEISERSON, C., RANDALL, K., AND STARK, A. 1998. Detecting data races in Cilk programs that use locks. In Proceedings of the 10th Annual ACM Symposium on Parallel Algorithms and Architectures, Puerto Vallarta, Mexico.
17. CHOI, J., BURKE, M., AND CARINI, P. 1993. Efficient flow-sensitive interproeedural computation of pointer-induced aliases and side effects. In Conference Record of the Twentieth Annual Symposium on Principles of Programming Languages, Charleston, SC.
18. CHOI, J., GUPTA, M., SERRANO, M., SREEDHAR, V., AND MIDKIFF, S. 1999. Escape analysis for Java. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO.
19. CHOW, J.-H. AND HARRISON, W. 1992a. Compile-time analysis of parallel programs that share memory. In Proceedings of the 19th Annual ACM Symposium on the Principles of Programming Languages, Albuquerque, NM.
20. CHOW, J.-H. AND HARHISON, W. 1992b. A general framework for analyzing shared-memory programs. In Proceedings of the 1992 International Conference on Parallel Processing, Ann Arbor, MI.
21. CORBETT, J. 1996. Evaluating deadlock detection methods for concurrent software. IEEE Trans. Softw. Eng. 22, 3 (Mar.), 161-180.
22. COUSOT, P. AND COUSOT, R. 1984. Automatic Program Construction Techniques. Macmillan Publishing Company, New York, NY.
23. DAS, M. 2000. Unification-based pointer analysis with bidirectional assignments. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada.
24. DETLEFS, D., LEINO, K. R., NELSON, G., AND SAXE, J. 1998. Extended static checking, Tech. Rep. 159, Compaq Systems Research Center.
25. DILLON, L. 1990. Using symbolic execution for verification of Ada tasking programs. ACM Trans. Prog. Lang. Syst. 12, 4, 643-669.
26. DINIZ, P. AND RINARD, M. 1997. Synchronization transformations for parallel computing. In Proceedings of the 24th Annual ACM Symposium on the Principles of Programming Languages, Paris, France, 187-200.
27. DINIZ, P. AND RINARD, M. 1998. Lock coarsening: Eliminating lock overhead in automatically parallelized object-based programs. J. Parallel Distrib. Comput. 49, 2 (Mar.), 2218-244.
28. DINNING, A. AND SCHONBERG, E. 1991. Detecting access anomalies in programs with critical sections, In Proceedings of the ACM/ONR Workshop on Parallel and Distributed Debugging, Santa Cruz, CA.
29. DIWAN, A., McKINLEY, K., AND Moss, E. 1998. Tye-based alias analysis. In Proceedings of the SIGPLAN '98 Conference on Program Language Design and Implementation, Montreal, Canada.
30. DUESTERWALD, E. AND SOFFA, M. 1991. Concurrency analysis in the presence of procedures using a data-flow framework. In 1991 International Symposium on Software Testing and Analysis, Victoria, Canada.
31. DWYER, M. AND CLARKE, L. 1994. Data flow analysis for verifying properties of concurrent programs. In Proceedings of the ACM SIGSOFT '94 Symposium on the Foundations of Software Engineering, New Orleans, LA.
32. EMAMI, M., GHIYA, R., AND HENDREN, L. 1994. Context-sensitive interprocedural points-to analysis in the presence of function pointers. In Proceedings of the SIGPLAN '94 Conference on Program Language Design and Implementation, Orlando, FL.
33. EMRATH, P., GHOSH, S., AND PADUA, D. 1989. Event synchronization analysis for debugging parallel programs. In Proceedings of Supercomputing '89, Reno, NV.
34. EMRATH, P. AND PADUA, D. 1988. Automatic detection of nondeterminacy in parallel programs. In Proceedings of the ACM SIGPLAN and SIGOPS Workshop on Parallel and distributed debugging, Madison, WI.
35. FALSAFI, B., LEBECK, A., REINHARDT, S., SCHOINAS, I., HILL, M., LARUS, J., ROGERS, A., AND WOOD, D. 1994. Application-specific protocols for user-level shared memory. In Proceedings of Supercomputing '94, Washington, DC, IEEE Computer Society Press, Los Alamitos, Calif., 380-389.
36. FLANAGAN, C. AND ABADI, M. 1999. Types for safe locking. In Proceedings of the 1999 European Symposium on Programming, Amsterdam, The Netherlands.
37. FLANAGAN, C. AND FREUND, S. 2000. Type-based race detection for Java. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada.
38. FRIGO, M., LEISERSON, C., AND RANDALL, K. 1998. The implementation of the Cilk-5 multithreaded language. In Proceedings of the SIGPLAN '98 Conference on Program Language Design and Implementation, Montreal, Canada.
39. GODEFROID, A. AND WOLPER, P. 1994. A partial approach to model checking. Information and Computation 110, 2 (May), 305-326.
40. GRUNWALD, D. AND SRINIVASAN, H. 1993. Data flow equations for explicitly parallel programs. In Proceedings of the 4th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, San Diego, CA.
41. HAUSER, C., JACOBI, C., THEIMER, M., WELCH, B., AND WEISER, M. 1993. Using threads in interactive systems: A case study. In Proceedings of the Fourteenth Symposium on Operating Systems Principles, Asheville, NC.
42. HEINTZE, N. AND TAEDIEU, O. 2001. Ultra-fast aliasing analysis using CLA: a million lines of C code in a second. In Proceedings of the SIGPLAN '01 Conference on Program Language Design and Implementation, Snowbird, UT.
43. HICKS, J. 1993. Experiences with compiler-directed storage reclamation. In Proceedings of the FPCA '93 Conference on Functional Programming Languages and Computer Architecture, 95-105.
44. HIND, M. 2001. Pointer analysis: Haven't we solved this problem yet? In Proceedings of the SIGPLAN-SIGSOFT '01 Workshop on Program Analysis for Software Tools and Engineering, Snowbird, UT.
45. KNOOP, J. 1998. Code motion for explicitly parallel programs. In Proceedings of the 4th European Conference on Parallel Processing (Euro-Par'98), Southampton, UK.
46. KNOOP, J. AND STEFFEN, B. 1999. Code motion for explicitly parallel programs. In Proceedings of the 7th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Atlanta, GA.
47. KNOOP, J., STEFFEN, B., AND VOLLMER, J. 1996. Parallelism for free: Efficient and optimal bitvector analyses for parallel programs. ACM Trans. Program. Lang. Syst. 18, 3 (May), 268-299.
48. KRISHNAMURTHY, A. AND YELICK, K. 1995. Optimizing parallel programs with explicit synchronization. In Proceedings of the SIGPLAN '95 Conference on Program Language Design and Implementation, La Jolla, CA.
49. KRISHNAMURTHY, A. AND YELICK, K. 1996. Analyses and optimizations for shared address space programs. J. Parallel Distrib. Comput. 38, 2, 130-144.
50. LANDI, W. AND RYDER, B. 1992. A safe approximation algorithm for interprocedural pointer aliasing. In Proceedings of the SIGPLAN '92 Conference on Program Language Design and Implementation, San Francisco, CA.
51. LEE, J., MIDKIFF, S. P., AND PADUA, D. A. 1998. A constant propagation algorithm for explicitly parallel programs. Intern. J. Parallel Program. 26, 5, 563-589.
52. LEE, J. AND PADUA, D. 2000. Hiding relaxed memory consistency with compilers. In Proceedings of the International Conference on Parallel Architectures and Compilation Techniques (PACT '00), Philadelphia, PA.
53. LEE, J., PADUA, D. A., AND MIDKIFF, S. P. 1999. Basic compiler algorithms for parallel programs. In Proceedings of the 7th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Atlanta, GA.
54. LONG, D. AND CLARKE, L. 1991. Data flow analysis of concurrent systems that use the rendezvous model of synchronization. In 1991 International Symposium on Software Testing and Analysis, Victoria, Canada.
55. MASTICOLA, S. AND RYDER, B. 1990. Static infinite wait anomaly detection in polynomial time. In Proceedings of the 1990 International Conference on Parallel Processing, St. Charles, IL.
56. MASTICOLA, S. AND RYDER, B. 1993. Non-concurrency analysis. In Proceedings of the 4th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, San Diego, CA.
57. MELLOR-CRUMMEY, J. 1991. On-the-fly detection of data races for programs with nested fork-join parallelism. In Proceedings of Supercomputing '91. Albuquerque, NM.
58. MIDKIFF, S. AND PADUA, D. 1990. Issues in the optimization of parallel programs. In Proceedings of the 1990 International Conference on Parallel Processing, II-105-113.
59. MIN, S. AND CHOI, J. 1991. Race Frontier: Reproducing data races in parallel-program debugging. In Proceedings of the 3rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Williamsburg, VA.
60. MORITZ, A., FRANK, M., AND AMARASINGHE, S. 2000. FlexCache: A framework for flexible compiler generated data caching. In The 2nd Workshop on Intelligent Memory Systems, Boston, MA.
61. NAUMOVICH, G. AND AVRUNIN, G. 1998. A conservative data flow algorithm for detecting all pairs of statements that may happen in parallel. In Proceedings of the ACM SIGSOFT '98 Symposium on the Foundations of Software Engineering, Lake Buena Vista, FL.
62. NAUMOVICH, G., AVRUNIN, G., AND CLARKE, L. 1999. An efficient algorithm for computing MHP information for concurrent Java programs. In Proceedings of the ACM SIGSOFT '99 Symposium on the Foundations of Software Engineering, Toulouse, France.
63. NETZER, R. AND MILLER, B. 1991. Improving the accuracy of data race detection. In Proceedings of the 3rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Williamsburg, VA.
64. O'CALLAHAN, R. AND JACKSON, D. 1997. Lackwit: A program understanding tool based on type inference. In 1997 International Conference on Software Engineering, Boston, MA.
65. REPPY, J. 1992. Higher-order concurrency. Ph.D. thesis, Dept. of Computer Science, Cornell Univ., Ithaca, NY.
66. RINARD, M. 1999. Effective fine-grain synchronization for automatically parallelized programs using optimistic synchronization primitives. ACM Trans. Comput. Syst. 17, 4 (Nov.), 337-371.
67. RINARD, M. 2001. Analysis of multithreaded programs. In Proceedings of the 8th Static Analysis Symposium, Paris, France.
68. ROUNTEV, A. AND CHANDRA, S. 2000. Off-line variable substitution for scaling points-to analysis. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada.
69. RUF, E. 1995. Context-insensitive alias analysis reconsidered. In Proceedings of the SIGPLAN '95 Conference on Program Language Design and Implementation, La Jolla, CA.
70. RUF, E. 2000. Effective synchronization removal for Java. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada.
71. RUGINA, R. AND RTNARD, M. 1999. Automatic parallelization of divide and conquer algorithms. In Proceedings of the 7th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Atlanta, GA.
72. RUGINA, R. AND RINARD, M. 2000. Symbolic bounds analysis of pointers, array indexes, and accessed memory regions. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada.
73. RYDER, B., LANDI, W., STOCKS, P., ZHANG, S., AND ALTUCHER, R. 2001. A schema for interprocedural modification side-effect analysis with pointer aliasing. ACM Trans. Program. Lang. Syst. 23, 1 (Mar.), 105-186.
74. SAGIV, M., REPS, T., AND WILHELM, R. 1998. Solving shape-analysis problems in languages with destructive updating. ACM Trans. Program. Lang. Syst 20, 1 (Jan.), 1-50.
75. SALCIANU, A. AND RINARD, M. 2001. Pointer and escape analysis for multithreaded programs. In Proceedings of the 8th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Snowbird, Utah.
76. SARKAR, V. 1997. Analysis and optimization of explicitly parallel programs using the parallel program graph representation. In Proceedings of the Tenth Workshop on Languages and Compilers for Parallel Computing, Minneapolis, MN.
77. SAVAGE, S., BURROWS, M., NELSON, G., SOLBOVARRO, P., AND ANDERSON, T. 1997. Eraser: A dynamic race detector for multi-threaded programs. ACM Trans. Comput. Syst. 15, 4, 391-411.
78. SHAPIRO, M. AND HORWITZ, S. 1997. Fast and accurate flow-insensitive points-to analysis. In Proceedings of the 24th Annual ACM Symposium on the Principles of Programming Languages, Paris, France.
79. SHASHA, D. AND SNIR, M. 1988. Efficient and correct execution of parallel programs that share memory. ACM Trans. Program. Lang. Syst. 10, 2 (Apr.).
80. SRINIVASAN, H., HOOK, J., AND WOLFE, M. 1993. Static single assignment for explicitly parallel programs. In Proceedings of the 20th Annual ACM Symposium on the Principles of Programming Languages, Charleston, SC.
81. STEELE, G. 1990. Making asynchronous parallelism safe for the world. In Proceedings of the 17th Annual ACM Symposium on the Principles of Programming Languages, San Francisco, CA.
82. STEENSGAARD, B. 1996. Points-to analysis in almost linear time. In Proceedings of the 23rd Annual ACM Symposium on the Principles of Programming Languages, St. Petersburg Beach, FL.
83. STEPHENSON, M., BABB, J., AND AMARASINGHE, S. 2000. Bitwidth analysis with application to silicon compilation. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada.
84. STERLING, N. 1994. Warlock: A static data race analysis tool. In Proceedings of the 1993 Winter Usenix Conference, San Diego, CA.
85. TAYLOR, R. N. 1983. A general purpose algorithm for analyzing concurrent programs. Commun. ACM 26, 5 (May), 362-376.
86. TSENG, C. 1995. Compiler optimizations for eliminating barrier synchronization. In Proceedings of the 5th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. ACM, New York, Santa Barbara, CA, 144-155.
87. VALMAEI, A. 1990. A stubborn attack on state explosion. In Proceedings of the 2nd International Workshop on Computer Aided Verification, New Brunswick, NJ.
88. WHALEY, J. AND RINARD, M. 1999. Compositional pointer and escape analysis for Java programs. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO.
89. WILSON, R. AND LAM, M. 1995. Efficient context-sensitive pointer analysis for C programs. In Proceedings of the SIGPLAN '95 Conference on Program Language Design and Implementation, La Jolia, CA.
90. ZHU, Y. AND HENDREN, L. 1997. Locality analysis for parallel C programs. In Proceedings of the International Conference on Parallel Architectures and Compilation Techniques (PACT'97), San Francisco, CA.
91. ZHU, Y. AND HENDREN, L. 1998. Communication optimizations for parallel C programs. In Proceedings of the SIGPLAN '98 Conference on Program Language Design and Implementation, Montreal Canada.