Identifying Parallelism in Construction Operations of Cyclic Pointer-Linked Data Structures 1

Transcription

1 Identifying Parallelism in Construction Operations of Cyclic Pointer-Linked Data Structures 1 Yuan-Shin Hwang Department of Computer Science National Taiwan Ocean University Keelung Taiwan shin@cs.ntou.edu.tw Abstract Pointer analysis has been an active research field in recent years. Combining pointer analysis and dependence analysis can identify parallelism in programs with pointers or dynamic pointer-linked data structures. After parallelism is identified, programs can be parallelized and then executed on parallel multiprocessor systems to achieve good performance. The compiler analysis techniques that have been proposed so far can only analyze parallelism in the traversal operations in programs with dynamic pointer-linked data structures. As a result, only the traversal operations will be parallelized while the construction operations will be executed in sequential. Although the traversal phase of such programs, which usually account for over 90% of total execution times, can be parallelized, the rest of programs that accounts for less than 10% will dominate the execution on multiprocessor systems. This paper presents a technique that can identify parallelism in the construction phase of programs with pointer-linked data structures. Experiment results show this approach can parallelize the construction phase of such programs and achieve good speedup on multiprocessor systems. Keywords: Parallelizing Compilers, Pointer Analysis, Multiprocessor Systems, Pointer-linked Data Structures Introduction Dependence analysis with the help of pointer analysis [1,3,4,5,13,16,18,19,20] or shape analysis [2,6,15,17] is the key technique to identify parallelism with dynamic pointer-lined data structures. There have been dependence analysis techniques proposed to analyze such programs [7,9,10,11,14]. These techniques can identify parallelism in programs with tree-like structures. However, they cannot recognize parallelism in programs with cyclic pointer-linked data structures even though the traversal patterns of these programs exhibit high degree of parallelism. A recent algorithm has been proposed to identify the traversal patterns of programs with cyclic graphs, isolate the statements that traverse or define the links of traversal patterns, and then analyze the data dependence and shape information of these statements [12]. Consequently, this approach can identify parallelism based on data dependence and shape analysis on programs even with cyclic graphs. This approach has been applied to identify parallelism in the traversal phase of some well-known application programs with cyclic graphs and obtain over 90% parallelism coverage [8] of these programs. However, this approach can only analyze dependence of the traversal phase of programs with cyclic graphs, but not the graph construction phase, which accounts for less than 10% 1 This research was supported in part by NSC grant NSC E T 1

2 of execution times. Although the part of programs with cyclic graphs that accounts for over 90% of execution times can be parallelized, the rest 10% will be executed sequentially and consequently will dominate the execution on multiprocessor systems. In order to achieve good scalability, the graph construction phase of such programs must be parallelized as well. This work intends to develop a technique to identify parallelism in the graph construction phase of programs with cyclic graphs. Algorithm The required condition of identifying parallelism in construction operations of programs with cyclic dynamic pointer-linked data structures is that the traversal operations of the programs on the constructed data structures are independent. In other words, if traversal operations on pointer-linked data structures in a program can be executed in any order, it implies the nodes of the traversed data structures can be connected in any order. Parallelism in construction operations exists if this condition holds, i.e. nodes of pointer-linked data structures in the program can be connected in any order. One typical example is the list representation of adjacent matrixes, each of which can represented by a list of lists. The lists of such a list of lists can be built independently. This proposal develops the following compiler analysis technique to detect such parallelism. The technique can be divided into the following steps: 1. Compute definition-use chains Each traversal operation corresponds to a read reference on pointer-linked data structures, while each construction operation corresponds to a write reference. Since a read reference is commonly called as a use and a write reference is called as a definition, the relationships between construction operations and traversal operations of dynamic pointer-linked data structures can be represented by definition-use chains of the data structures. 2. Recognize parallelism in traversal operations If there is no parallelism in traversal operations, then it means the traversal operations must follow certain orders and consequently the construction operations of such pointer-linked data structures have to be executed following the sequential order. On the other hand, if traversal operations are independent, it means the traversal operations on data structures can be executed in any order. Therefore, the construction operations of the pointer-linked data structures that are accessed by independent traversal operations might be able to be executed in any order. In other words, parallelism might exist in construction operations of these data structures. 3. Identify parallelism in construction operations For each construction operation of dynamic pointer-linked data structures, compilers will have to examine all corresponding traversal operations on the constructed data structures. If any of the corresponding traversal operations are not independent, then construction operations will be assumed to be sequential. Otherwise, further analysis will be performed to identify parallelism in construction operations. The construction phase of dynamic pointer-linked data structures can be executed in parallel if the following two conditions are met: The pointer-linked data structures built by the construction phase are accessed only by traversal operations that can be executed in parallel. The pointer-linked data structures are not modified between the construction phase and the traversal phase. 2

3 Experimental Results Two benchmark programs EM3D and Moldyn are analyzed and parallelized. They are executed on the SGI Power Challenge 2 from 1 to 10 processors. The experimental results are compared as follows. EM3D When the construction phase is not parallelized, the construction phase takes over 43% of total execution time on 10 processors and the speedup is about 4.56: Construction Computation Total However, if the construction phase is parallelized, the construction phase takes only 10.5% of the total execution time on 10 processors and the speedup achieves 7.15: Construction Computation Total The above two tables are obtained by running EM3D for 100 iterations with 1024 E nodes and 1024 H nodes, each of which has a neighbor list of length 50. Moldyn A lattice of 9?9?9 will be simulated for 150 iterations. Neighbor list will be regenerated every 30 iterations with a cutoff distance of 6. When the construction phase is executed sequentially, the construction phase takes over 31% of total execution time on 10 processors and the speedup is about 6.45: Construction Total When the construction phase is parallelized, it only takes about 6% of total execution time and the speedup achieves 9.03 on 10 processors:. Construction Total Conclusions 2 Located at the National Center for High-Performance Computing 3

4 The technique developed can not only identify independent traversal operations in programs with dynamic pointer-linked data structures, but also detect parallelism in the construction phase of such programs. If only the first form of parallelism is identified, the parallelized programs would not scale well since the sequential part will dominate the execution times on multiprocessor systems. The technique proposed in the paper solves this problem by identifying the second form of parallelism. Once the construction phase of the programs with dynamic pointer-linked data structures are parallelized as well, good speedup can be achieved, as shown in the above tables. The technique proposed in this paper can be applied to scientific computational programs to achieve high performance on parallel multiprocessor systems since they usually build pointer-linked data structures to represent adjacent matrices, which in turn describe the interactions of simulated objects. Michael Burke, Paul Carini, Jong-Deok Choi, and Michael Hind. Flow-insensitive interprocedural alias analysis in the presence of pointers. Proceedings of the 8th International Workshop on Languages and Compilers for Parallel Computing}, Columbus, Ohio, August 1995 David R. Chase, Mark Wegman, and F.~Kenneth Zadeck. Analysis of pointers and structures. SIGPLAN Notices}, 25(6): , June Proceedings of the ACM SIGPLAN '90 Conference on Programming Jong-Deok Choi, Michael Burke, and Paul Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. Conference Record of the Twentieth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages , Charleston, South Carolina, January 1993 Alain Deutsch. Interprocedural May-Alias analysis for pointers: Beyond k-limiting. SIGPLAN Notices, 29(6): , June Proceedings of the ACM SIGPLAN '94 Conference on Programming Language Design and Implementation Maryam Emami, Rakesh Ghiya, and Laurie~J. Hendren. Context-sensitive interprocedural Points-to analysis in the presence of function pointers. SIGPLAN Notices, 29(6): , June Proceedings of the ACM SIGPLAN '94 Conference on Programming Rakesh Ghiya and Laurie~J. Hendren. Is it a tree, a DAG, or a cyclic graph? A shape analysis for heap-directed pointers in C. Conference Record of POPL '96: 23nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 1--15, St. Petersburg Beach, Florida, January 1996 Vincent A. Guarna, Jr. A technique for analyzing pointer and structure references in parallel restructuring compilers. Proceedings of 1988 International Conference on Parallel Processing, Volume 2, pages , August 1988 Mary W. Hall, Saman P. Amarasinghe, Brian R. Murphy, Shih-Wei Liao, and Monica S. Lam. Detecting coarse - grain parallelism using an interprocedural parallelizing compiler. In Proceedings of Supercomputing'95, December 1995 Laurie J. Hendren and Alexandru Nicolau. Parallelizing programs with recursive data structures. IEEE Transactions on Parallel and Distributed Systems, 1(1):35--47, January 1990 Susan Horwitz, Phil Pfeiffer, and Thomas Reps. Dependence analysis for pointer variables. SIGPLAN Notices, 24(7):28--40, July Proceedings of the ACM SIGPLAN '89 Conference on Programming Joseph Hummel, Laurie J. Hendren, and Alexandru Nicolau. A general data dependence test for dynamic, pointer-based data structures. SIGPLAN Notices, 29(6): , June Proceedings of the ACM SIGPLAN '94 Conference on Programming Yuan-Shin Hwang. Interprocedural Definition-Use Chains of Dynamic Recursive Data Structure. PhD thesis, University of Maryland, 1998 William Landi and Barbara G. Ryder. A safe approximate algorithm for interprocedural pointer aliasing. SIGPLAN Notices, 27(7): , July Proceedings of the ACM SIGPLAN '92 Conference on Programming James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. SIGPLAN Notices, 23(7):21--34, July Proceedings of the ACM SIGPLAN '88 Conference on Programming Language Design and Implementation J. Plevyak, A. Chien, and V. Karamcheti. Analysis of dynamic structures for efficient parallel execution. Proceedings of the 6th International Workshop on Languages and Compilers for Parallel Computing, pages 4

5 37--56, Portland, Oregon, August Lecture Notes in Computer Science, Vol. 768, Springer Verlag Erik Ruf. Context-insensitive alias analysis reconsidered. SIGPLAN Notices, 30(6):13--22, June Proceedings of the ACM SIGPLAN '95 Conference on Programming Mooly Sagiv, Thomas Reps, and Reinhard Wilhelm. Solving shape-analysis problems in languages with destructive updating. Conference Record of POPL '96: 23nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages , St. Petersburg Beach, Florida, January 1996 Marc Shapiro and Susan Horwitz. Fast and accurate flow-insensitive points-to analysis. Conference Record of 24nd ACM Symposium on Principles of Programming Languages, pages 1--14, Paris, France, January 1997 Bjarne Steensgaard. Points-to analysis in almost linear time. Conference Record of POPL '96: 23nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages , St. Petersburg Beach, Florida, January 1996 Robert P. Wilson and Monica S. Lam. Efficient context-sensitive pointer analysis for C programs. SIGPLAN Notices, 30(6):1--12, June Proceedings of the ACM SIGPLAN '95 Conference on Programming 5