The Experts below are selected from a list of 6396 Experts worldwide ranked by ideXlab platform
D. Wonnacott - One of the best experts on this subject based on the ideXlab platform.
-
Going beyond integer programming with the Omega test to eliminate false data dependences
IEEE Transactions on Parallel and Distributed Systems, 1995Co-Authors: W. Pugh, D. WonnacottAbstract:Array data dependence analysis methods currently in use generate false dependences that can prevent useful program transformations. These false dependences arise because the questions asked are conservative approximations to the questions we really should be asking. Unfortunately, the questions we really should be asking go beyond integer programming and require decision procedures for a subclass of Presburger formulas. In this paper, we describe how to extend the Omega test so that it can answer these queries and allow us to eliminate these false data dependences. We have implemented the techniques described here and believe they are suitable for use in production compilers.
-
PLDI - Eliminating false data dependences using the Omega test
Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation - PLDI '92, 1992Co-Authors: W. Pugh, D. WonnacottAbstract:Array data dependence analysis methods currently in use generate false dependences that can prevent useful program transformations. These false dependences arise because the questions asked are conservative approximations to the questions we really should be asking. Unfortunately, the questions we really should be asking go beyond integer programming and require decision procedures for a sublcass of Presburger formulas. In this paper, we describe how to extend the Omega test so that it can answer these queries and allow us to eliminate these false data dependences. We have implemented the techniques described here and believe they are suitable for use in production compilers.
K. Kyriakopoulos - One of the best experts on this subject based on the ideXlab platform.
-
Data dependence analysis techniques for increased accuracy and extracted parallelism
International Journal of Parallel Programming, 2004Co-Authors: K. Kyriakopoulos, Kleanthis PsarrisAbstract:Parallelizing compilers rely on data dependence information in order to produce valid parallel code. Traditional data dependence analysis techniques. such as the Banerjee test and the I-Test, can efficiently compute data dependence information for simple instances of the data dependence problem. However, in more complex cases involving triangular or trapezoidal loop regions, symbolic variables, and multidimensional arrays with coupled subscripts these tests, including the triangular Banerjee test, ignore or simplify many of the constraints and thus introduce approximations, especially when testing for data dependence under direction vector constraints. The Omega test can accurately handle such complex cases, but at a higher computation cost. In this paper we extend the ideas behind the I-Test and present new techniques to handle complex instances of tile dependence problem, which are frequently found in actual source code. In particular, we provide polynomial-time techniques that can prove or disprove data dependences, subject to any direction vector, in loops with triangular or trapezoidal bounds, symbolic variables and multidimensional arrays with coupled subscripts. We also investigate the impact of the proposed data dependence analysis techniques in practice. We perform an extensive experimental evaluation of the data dependence analysis tests, including the I-Test, the Omega test and the proposed new techniques. We compare these tests in terms of data dependence accuracy, compilation efficiency and effectiveness in program parallelization. We run several experiments using the Perfect Club benchmarks and the scientific library Lapack. We analyze the trade-off between accuracy and efficiency and the reasons for any approximation of each data dependence test. We determine the impact of the dependence analysis phase on the total compilation time and we measure the number of loops parallelized by each test. We conclude that we can employ, polynomial-time techniques to improve data dependence accuracy and increase program parallelization to a reasonable computation cost.
-
An experimental evaluation of data dependence analysis techniques
IEEE Transactions on Parallel and Distributed Systems, 2004Co-Authors: K. Psarris, K. KyriakopoulosAbstract:Optimizing compilers rely upon program analysis techniques to detect data dependences between program statements. Data dependence information captures the essential ordering constraints of the statements in a program that need to be preserved in order to produce valid optimized and parallel code. Data dependence testing is very important for automatic parallelization, vectorization, and any other code transformation. In this paper, we examine the impact of data dependence analysis in practice. A number of data dependence tests have been proposed in the literature. In each test, there are different trade offs between accuracy and efficiency. We present an experimental evaluation of several data dependence tests, including the Banerjee test, the I-Test, and the Omega test. We compare these tests in terms of data dependence accuracy, compilation efficiency, effectiveness in parallelization, and program execution performance. We analyze the reasons why a data dependence test can be inexact and we explain how the examined tests handle such cases. We run various experiments using the Perfect Club Benchmarks and the scientific library Lapack. We present the measured accuracy of each test and the reasons for any approximation. We compare these tests in term's of efficiency and we analyze the trade offs between accuracy and efficiency. We also determine the impact of each data dependence test on the total compilation time. Finally, we measure the number of loops parallelized by each test and we compare the execution performance of each benchmark on a multiprocessor. Our results indicate that the Omega test is more accurate, but also very inefficient in the cases where the other two tests are inaccurate. In general, the cost of the Omega test is high and uses a significant percentage of the total compilation time. Furthermore, the difference in accuracy of the Omega test over the Banerjee test and the l-Test does not improve parallelization and program execution performance.
-
ICS - The impact of data dependence analysis on compilation and program parallelization
Proceedings of the 17th annual international conference on Supercomputing - ICS '03, 2003Co-Authors: Kleanthis Psarris, K. KyriakopoulosAbstract:Optimizing compilers rely upon program analysis techniques to detect data dependences between program statements. Data dependence information captures the essential ordering constraints of the statements in a program that need to be preserved in order to produce valid optimized and parallel code. Data dependence testing is very important for automatic parallelization, vectorization and any other code transformation. In this paper we examine the impact of data dependence analysis in practice. A number of data dependence tests have been proposed in the literature. In each test there are different tradeoffs between accuracy and efficiency. We present an experimental evaluation of several data dependence tests, including the Banerjee test, the I-Test and the Omega test. We compare these tests in terms of data dependence accuracy, compilation efficiency, effectiveness in parallelization and program execution performance. We analyze the reasons why a data dependence test can be inexact and we explain how the examined tests handle such cases. We run various experiments using the Perfect Club Benchmarks and the scientific library Lapack. We present the measured accuracy of each test and the reasons for any approximation. We compare these tests in terms of efficiency and we analyze the tradeoffs between accuracy and efficiency. We also determine the impact of each data dependence test on the total compilation time. Finally, we measure the number of loops parallelized by each test and we compare the execution performance of each benchmark on a multiprocessor. Our results indicate that the Omega test is more accurate, but also very inefficient in the cases where the other two tests are inaccurate. In general the cost of the Omega test is high and a significant percentage of the total compilation time. Furthermore, the difference in accuracy of the Omega test over the Banerjee test and the I-Test does not improve parallelization and program execution performance.
-
ICPP - Data dependence analysis for complex loop regions
International Conference on Parallel Processing 2001., 2001Co-Authors: K. Kyriakopoulos, K. PsarrisAbstract:Parallelizing compilers rely on data dependence information in order to produce valid parallel code. Polynomial data dependence analysis techniques, such as the Banerjee test and the I-Test, can efficiently compute data dependence information for simple instances of the data dependence problem. In more complicated cases such as triangular or trapezoidal loop regions with direction vector constraints these tests, including the triangular Banerjee test, ignore or simplify many of the constraints and thus introduce further approximations. The I-Test and the Omega test are two data dependence tests that can provide exact data dependence information. In addition the Omega test can accurately handle complex loop regions but at a higher computation cost. We extend the ideas behind the I-Test to handle such complex regions which are frequently found in actual source code. In particular, we provide a polynomial-time algorithm, the VI-Test that can detect data dependences in loops with triangular bounds and symbolic variables subject to any direction vector. We also perform an extensive experimental evaluation of the various dependence tests, including the I-Test, the VI-Test and the Omega test. We run several experiments using the Perfect Club Benchmarks and the scientific libraries Eispack, Linpack and Lapack. We present accuracy results, reasons for inconclusive answers, and comparative efficiency metrics.
-
Data dependence analysis for complex loop regions
International Conference on Parallel Processing 2001., 2001Co-Authors: K. Kyriakopoulos, K. PsarrisAbstract:Parallelizing compilers rely on data dependence information in order to produce valid parallel code. Polynomial data dependence analysis techniques, such as the Banerjee test and the I-Test, can efficiently compute data dependence information for simple instances of the data dependence problem. In more complicated cases such as triangular or trapezoidal loop regions with direction vector constraints these tests, including the triangular Banerjee test, ignore or simplify many of the constraints and thus introduce further approximations. The I-Test and the Omega test are two data dependence tests that can provide exact data dependence information. In addition the Omega test can accurately handle complex loop regions but at a higher computation cost. We extend the ideas behind the I-Test to handle such complex regions which are frequently found in actual source code. In particular, we provide a polynomial-time algorithm, the VI-Test that can detect data dependences in loops with triangular bounds and symbolic variables subject to any direction vector. We also perform an extensive experimental evaluation of the various dependence tests, including the I-Test, the VI-Test and the Omega test. We run several experiments using the Perfect Club Benchmarks and the scientific libraries Eispack, Linpack and Lapack. We present accuracy results, reasons for inconclusive answers, and comparative efficiency metrics.
K. Psarris - One of the best experts on this subject based on the ideXlab platform.
-
An experimental evaluation of data dependence analysis techniques
IEEE Transactions on Parallel and Distributed Systems, 2004Co-Authors: K. Psarris, K. KyriakopoulosAbstract:Optimizing compilers rely upon program analysis techniques to detect data dependences between program statements. Data dependence information captures the essential ordering constraints of the statements in a program that need to be preserved in order to produce valid optimized and parallel code. Data dependence testing is very important for automatic parallelization, vectorization, and any other code transformation. In this paper, we examine the impact of data dependence analysis in practice. A number of data dependence tests have been proposed in the literature. In each test, there are different trade offs between accuracy and efficiency. We present an experimental evaluation of several data dependence tests, including the Banerjee test, the I-Test, and the Omega test. We compare these tests in terms of data dependence accuracy, compilation efficiency, effectiveness in parallelization, and program execution performance. We analyze the reasons why a data dependence test can be inexact and we explain how the examined tests handle such cases. We run various experiments using the Perfect Club Benchmarks and the scientific library Lapack. We present the measured accuracy of each test and the reasons for any approximation. We compare these tests in term's of efficiency and we analyze the trade offs between accuracy and efficiency. We also determine the impact of each data dependence test on the total compilation time. Finally, we measure the number of loops parallelized by each test and we compare the execution performance of each benchmark on a multiprocessor. Our results indicate that the Omega test is more accurate, but also very inefficient in the cases where the other two tests are inaccurate. In general, the cost of the Omega test is high and uses a significant percentage of the total compilation time. Furthermore, the difference in accuracy of the Omega test over the Banerjee test and the l-Test does not improve parallelization and program execution performance.
-
ICPP - Data dependence analysis for complex loop regions
International Conference on Parallel Processing 2001., 2001Co-Authors: K. Kyriakopoulos, K. PsarrisAbstract:Parallelizing compilers rely on data dependence information in order to produce valid parallel code. Polynomial data dependence analysis techniques, such as the Banerjee test and the I-Test, can efficiently compute data dependence information for simple instances of the data dependence problem. In more complicated cases such as triangular or trapezoidal loop regions with direction vector constraints these tests, including the triangular Banerjee test, ignore or simplify many of the constraints and thus introduce further approximations. The I-Test and the Omega test are two data dependence tests that can provide exact data dependence information. In addition the Omega test can accurately handle complex loop regions but at a higher computation cost. We extend the ideas behind the I-Test to handle such complex regions which are frequently found in actual source code. In particular, we provide a polynomial-time algorithm, the VI-Test that can detect data dependences in loops with triangular bounds and symbolic variables subject to any direction vector. We also perform an extensive experimental evaluation of the various dependence tests, including the I-Test, the VI-Test and the Omega test. We run several experiments using the Perfect Club Benchmarks and the scientific libraries Eispack, Linpack and Lapack. We present accuracy results, reasons for inconclusive answers, and comparative efficiency metrics.
-
Data dependence analysis for complex loop regions
International Conference on Parallel Processing 2001., 2001Co-Authors: K. Kyriakopoulos, K. PsarrisAbstract:Parallelizing compilers rely on data dependence information in order to produce valid parallel code. Polynomial data dependence analysis techniques, such as the Banerjee test and the I-Test, can efficiently compute data dependence information for simple instances of the data dependence problem. In more complicated cases such as triangular or trapezoidal loop regions with direction vector constraints these tests, including the triangular Banerjee test, ignore or simplify many of the constraints and thus introduce further approximations. The I-Test and the Omega test are two data dependence tests that can provide exact data dependence information. In addition the Omega test can accurately handle complex loop regions but at a higher computation cost. We extend the ideas behind the I-Test to handle such complex regions which are frequently found in actual source code. In particular, we provide a polynomial-time algorithm, the VI-Test that can detect data dependences in loops with triangular bounds and symbolic variables subject to any direction vector. We also perform an extensive experimental evaluation of the various dependence tests, including the I-Test, the VI-Test and the Omega test. We run several experiments using the Perfect Club Benchmarks and the scientific libraries Eispack, Linpack and Lapack. We present accuracy results, reasons for inconclusive answers, and comparative efficiency metrics.
Todd C Mowry - One of the best experts on this subject based on the ideXlab platform.
-
Tolerating Dependences Between Large Speculative Threads Via Sub-Threads
33rd International Symposium on Computer Architecture (ISCA'06), 2006Co-Authors: Christopher B Colohan, A. Ailamaki, J.g. Steffan, Todd C MowryAbstract:Thread-level speculation (TLS) has proven to be a promising method of extracting parallelism from both integer and scientific workloads, targeting speculative threads that range in size from hundreds to several thousand dynamic instructions and have minimal dependences between them. Recent work has shown that TLS can offer compelling performance improvements for database workloads, but only when targeting much larger speculative threads of more than 50,000 dynamic instructions per thread, with many frequent data dependences between them. To support such large and dependent speculative threads, hardware must be able to buffer the additional speculative state, and must also address the more challenging problem of tolerating the resulting cross-thread data dependences. In this paper we present hardware support for large speculative threads that integrates several previous proposals for TLS hardware. We also introduce support for sub-threads; a mechanism for tolerating cross-thread data dependences by checkpointing speculative execution. When speculation fails due to a violated data dependence, with sub-threads the failed thread need only rewind to the checkpoint of the appropriate sub-thread rather than rewinding to the start of execution; this significantly reduces the cost of mis-speculation. We evaluate our hardware support for large and dependent speculative threads in the database domain and find that the transaction response time for three of the five transactions from TPC-C (on a simulated 4-processor chip-multiprocessor) speedup by a factor of 1.9 to 2.9
-
compiler optimization of memory resident value communication between speculative threads
Symposium on Code Generation and Optimization, 2004Co-Authors: Antonia Zhai, Christopher B Colohan, Gregory J. Steffan, Todd C MowryAbstract:Efficient inter-thread value communication is essential for improving performance in thread-level speculation (TLS). Although several mechanisms for improving value communication using hardware support have been proposed, there is relatively little work on exploiting the potential of compiler optimization. Building on recent research on compiler optimization of scalar value communication between speculative threads, we propose compiler techniques for the optimization of memory-resident values. In TLS, data dependences through memory-resident values are tracked by the underlying hardware and preserved by re-executing any speculative thread that violates a dependence; however, re-execution incurs a large performance penalty and should be used only to resolve data dependences that are infrequent. In contrast, value communication for frequently-occurring data dependences must be very efficient. We propose using the compiler to first identify frequently-occurring memory-resident data dependences, then insert synchronization for communicating values to preserve these dependences. We find that by synchronizing frequently-occurring data dependences we can significantly improve the efficiency of parallel execution. A comparison between compiler-inserted and hardware-inserted memory synchronization reveals that the two techniques are complementary, with each technique benefitting different benchmarks.
François Thomasset - One of the best experts on this subject based on the ideXlab platform.
-
Data Dependence Analysis of Assembly Code
International Journal of Parallel Programming, 2000Co-Authors: Wolfram Amme, François Thomasset, Peter Braun, Eberhard ZehendnerAbstract:Determination of data dependences is a task typically performed with high-level language source code in today's optimizing and parallelizing compilers. Very little work has been done in the field of data dependence analysis on assembly language code, but this area will be of growing importance, e.g., for increasing instruction-level parallelism. A central element of a data dependence analysis in this case is a method for memory reference disambiguation which decides whether two memory operations may access (or definitely access) the same memory location. In this paper we describe a new approach for the determination of data dependences in assembly code. Our method is based on a sophisticated algorithm for symbolic value propagation, and it can derive value-based dependences between memory operations instead of just address-based dependences. We have integrated our method into the Salto system for assembly language optimization. Experimental results show that our approach greatly improves the precision of the dependence analysis in many cases.
-
IEEE PACT - Data dependence analysis of assembly code
1998Co-Authors: Wolfram Amme, Eberhard Zehendner, Peter Braun, François ThomassetAbstract:Determination of data dependences is a task typically performed with high-level language source code in today's optimizing and parallelizing compilers. Very little work has been done in the field of data dependence analysis on assembly language code, but this area will be of growing importance, e.g. for increasing ILP. A central element of a data dependence analysis in this case is a method for memory reference disambiguation which decides whether two memory operations may/must access the same memory location. In this paper we describe a new approach for determination of data dependences in assembly code. Our method is based on a sophisticated algorithm for symbolic value propagation, and it can derive value-based dependences between memory operations instead of address-based dependences, only. We have integrated our method into the \salto\ system for assembly language optimization. Experimental results show that our approach greatly improves the accuracy of the dependence analysis in many cases.
-
Data dependence analysis of assembly code
Proceedings. 1998 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.98EX192), 1998Co-Authors: Wolfram Amme, Eberhard Zehendner, Peter Braun, François ThomassetAbstract:Determination of data dependences is a task typically performed with high-level language source code in today 's optimizing and parallelizing compilers. Very little work has been done in the field of data dependence analysis on assembly language code, but this area will be of growing importance, e.g. for increasing ILP. A central element of a data dependence analysis in this case is a method for memory reference disambiguation which decides whether two memory operations may/must access the same memory location. In this paper we describe a new approach for determination of data dependences in assembly code. Our method is based on a sophisticated algorithm for symbolic value propagation, and it can derive value-based dependences between memory operations instead of address-based dependences, only. We have integrated our method into the SALTO system for assembly language optimization. Experimental results show that our approach greatly improves the accuracy of the dependence analysis in many cases.
