Compiler support for speculative multithreading architecture with probabilistic points-to analysis

Speculative multithreading (SpMT) architecture can exploit thread-level parallelism that cannot be identified statically. Speedup can be obtained by speculatively executing threads in parallel that are extracted from a sequential program. However, performance degradation might happen if the threads are highly dependent, since a recovery mechanism will be activated when a speculative thread executes incorrectly and such a recovery action usually incurs a very high penalty. Therefore, it is essential for SpMT to quantify the degree of dependences and to turn off speculation if the degree of dependences passes certain thresholds. This paper presents a technique that quantitatively computes dependences between loop iterations and such information can be used to determine if loop iterations can be executed in parallel by speculative threads. This technique can be broken into two steps. First probabilistic points-to analysis is performed to estimate the probabilities of points-to relationships in case there are pointer references in programs, and then the degree of dependences between loop iterations is computed quantitatively. Preliminary experimental results show compiler-directed thread-level speculation based on the information gathered by this technique can achieve significant performance improvement on SpMT.

[1]  G. Ramalingam Data flow frequency analysis , 1996, PLDI '96.

[2]  Todd M. Austin,et al.  The SimpleScalar tool set, version 2.0 , 1997, CARN.

[3]  Jenq Kuen Lee,et al.  A Function-Composition Approach to Synthesize Fortran 90 Array Operations , 1998, J. Parallel Distributed Comput..

[4]  Kunle Olukotun,et al.  The Stanford Hydra CMP , 2000, IEEE Micro.

[5]  Jenq Kuen Lee,et al.  Data distribution analysis and optimization for Pointer-based distributed programs , 1997, Proceedings of the 1997 International Conference on Parallel Processing (Cat. No.97TB100162).

[6]  Alex Berson,et al.  Building Data Mining Applications for CRM , 1999 .

[7]  Jong-Deok Choi,et al.  Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects , 1993, POPL '93.

[8]  Steven S. Muchnick,et al.  Advanced Compiler Design and Implementation , 1997 .

[9]  Martin C. Rinard,et al.  Pointer analysis for multithreaded programs , 1999, PLDI '99.

[10]  Jian Huang,et al.  The Superthreaded Processor Architecture , 1999, IEEE Trans. Computers.

[11]  Bjarne Steensgaard,et al.  Points-to analysis in almost linear time , 1996, POPL '96.

[12]  Jong-Deok Choi,et al.  Flow-Insensitive Interprocedural Alias Analysis in the Presence of Pointers , 1994, LCPC.

[13]  David A. Padua,et al.  Instance-wise points-to analysis for loop-based dependence testing , 2002, ICS '02.

[14]  Jenq Kuen Lee,et al.  Compiler Optimizations with DSP-Specific Semantic Descriptions , 2002, LCPC.

[15]  Thomas W. Reps,et al.  Pointer analysis for programs with structures and casting , 1999, PLDI '99.

[16]  Brian W. Kernighan,et al.  The C Programming Language , 1978 .

[17]  Jenq Kuen Lee,et al.  Probabilistic inference schemes for sparsity structures of Fortran 90 array intrinsics , 2001, International Conference on Parallel Processing, 2001..

[18]  Erik Ruf,et al.  Context-insensitive alias analysis reconsidered , 1995, PLDI '95.

[19]  Gurindar S. Sohi,et al.  Multiscalar processors , 1995, Proceedings 22nd Annual International Symposium on Computer Architecture.

[20]  Bjarne Stroustrup,et al.  The C++ programming language (2nd ed.) , 1991 .

[21]  Monica S. Lam,et al.  Efficient context-sensitive pointer analysis for C programs , 1995, PLDI '95.

[22]  Kunle Olukotun,et al.  Software and Hardware for Exploiting Speculative Parallelism with a Multiprocessor , 1997 .

[23]  Laurie J. Hendren,et al.  Context-sensitive interprocedural points-to analysis in the presence of function pointers , 1994, PLDI '94.

[24]  Brian W. Kernighan,et al.  The C Programming Language, Second Edition , 1988 .

[25]  Jenq Kuen Lee,et al.  Probabilistic Points-to Analysis , 2001, LCPC.

[26]  Jenn-Yuan Tsai,et al.  Compiler Techniques for the Superthreaded Architectures1, 2 , 1999, International Journal of Parallel Programming.

[27]  Susan Horwitz,et al.  Fast and accurate flow-insensitive points-to analysis , 1997, POPL '97.

[28]  Anne Rogers,et al.  Software caching and computation migration in Olden , 1995, PPOPP '95.

[29]  Jenq Kuen Lee,et al.  Compiler Analysis and Supports for Leakage Power Reduction on Microprocessors , 2002, LCPC.

[30]  Rakesh Krishnaiyer,et al.  An Advanced Optimizer for the IA-64 Architecture , 2000, IEEE Micro.

[31]  Manuvir Das,et al.  Unification-based pointer analysis with directional assignments , 2000, PLDI '00.

[32]  Matthew S. Hecht,et al.  Flow Analysis of Computer Programs , 1977 .

[33]  Roy Dz-Ching Ju,et al.  Probabilistic memory disambiguation and its application to data speculation , 1999, CARN.

[34]  Michael A. Harrison,et al.  Accurate static estimators for program optimization , 1994, PLDI '94.

[35]  Jenq Kuen Lee,et al.  Array Operation Synthesis to Optimize HPF Programs on Distributed Memory Machines , 2001, J. Parallel Distributed Comput..

[36]  Alain Deutsch,et al.  Interprocedural may-alias analysis for pointers: beyond k-limiting , 1994, PLDI '94.

[37]  Jenq Kuen Lee,et al.  Efficient support of parallel sparse computation for array intrinsic functions of Fortran 90 , 1998, ICS '98.

[38]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[39]  Josep Torrellas,et al.  A Chip-Multiprocessor Architecture with Speculative Multithreading , 1999, IEEE Trans. Computers.

[40]  Barbara G. Ryder,et al.  A safe approximate algorithm for interprocedural aliasing , 1992, PLDI '92.