Results 1  10
of
16
The Tao of Parallelism in Algorithms
 In PLDI
, 2011
"... For more than thirty years, the parallel programming community has used the dependence graph as the main abstraction for reasoning about and exploiting parallelism in “regular ” algorithms that use dense arrays, such as finitedifferences and FFTs. In this paper, we argue that the dependence graph i ..."
Abstract

Cited by 41 (12 self)
 Add to MetaCart
(Show Context)
For more than thirty years, the parallel programming community has used the dependence graph as the main abstraction for reasoning about and exploiting parallelism in “regular ” algorithms that use dense arrays, such as finitedifferences and FFTs. In this paper, we argue that the dependence graph is not a suitable abstraction for algorithms in new application areas like machine learning and network analysis in which the key data structures are “irregular ” data structures like graphs, trees, and sets. To address the need for better abstractions, we introduce a datacentric formulation of algorithms called the operator formulation in which an algorithm is expressed in terms of its action on data structures. This formulation is the basis for a structural analysis of algorithms that we call taoanalysis. Taoanalysis can be viewed as an abstraction of algorithms that distills out algorithmic properties
Commutativity Analysis for Software Parallelization: letting Program Transformations See the Big Picture
 In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems
, 2009
"... Extracting performance from manycore architectures requires software engineers to create multithreaded applications, which significantly complicates the already daunting task of software development. One solution to this problem is automatic compiletime parallelization, which can ease the burden ..."
Abstract

Cited by 25 (0 self)
 Add to MetaCart
(Show Context)
Extracting performance from manycore architectures requires software engineers to create multithreaded applications, which significantly complicates the already daunting task of software development. One solution to this problem is automatic compiletime parallelization, which can ease the burden on software developers in many situations. Clearly, automatic parallelization in its present form is not suitable for many application domains and new compiler analyses are needed address its shortcomings. In this paper, we present one such analysis: a new approach for detecting commutative functions. Commutative functions are sections of code that can be executed in any order without affecting the outcome of the application, e.g., inserting elements into a set. Previous research on this topic had one significant limitation, in that the results of a commutative functions must produce identical memory layouts. This prevented previous techniques from detecting functions like malloc, which may return different pointers depending on the order in which it is called, but these differing results do not affect the overall output of the application. Our new commutativity analysis correctly identify these situations to better facilitate automatic parallelization. We demonstrate that this analysis can automatically extract significant amounts of parallelism from many applications, and where it is ineffective it can provide software developers a useful list of functions that may be commutative provided semantic program changes that are not automatable.
A unified framework for nonlinear dependence testing and symbolic analysis
 In Proceedings of the ACM International Conference on Supercomputing (ICS
, 2004
"... This paper presents a unified approach for generalized induction variable recognition and substitution, pointer analysis, analysis of conditionally updated variables, value range analysis, array region analysis, and nonlinear dependence testing. The analysis techniques share a welldefined uniform a ..."
Abstract

Cited by 21 (8 self)
 Add to MetaCart
(Show Context)
This paper presents a unified approach for generalized induction variable recognition and substitution, pointer analysis, analysis of conditionally updated variables, value range analysis, array region analysis, and nonlinear dependence testing. The analysis techniques share a welldefined uniform approach based on the chains of recurrences algebra. The uniform algebraic approach provides a powerful unified framework for developing analysis algorithms for restructuring compilers. The paper introduces a new set of analysis algorithms that accurately handle conditional control flow, pointer arithmetic, and nonlinear symbolic expressions in loops, which are known to be problematic for conventional restructuring compilers.
Verification of Source Code Transformations by Program Equivalence Checking
 In Compiler Construction, 14th International Conference, CC 2005, Proceedings, volume 3443 of LNCS
, 2005
"... Typically, a combination of manual and automated transformations is applied when algorithms for digital signal processing are adapted for energy and performancee#cient embedded systems. This poses severe verification problems. Verification becomes easier after converting the code into dynamic s ..."
Abstract

Cited by 15 (6 self)
 Add to MetaCart
(Show Context)
Typically, a combination of manual and automated transformations is applied when algorithms for digital signal processing are adapted for energy and performancee#cient embedded systems. This poses severe verification problems. Verification becomes easier after converting the code into dynamic singleassignment form (DSA). This paper describes a method to prove equivalence between two programs in DSA where subscripts to array variables and loop bounds are (piecewise) a#ne expressions. For such programs, geometric modeling can be used and it can be shown, for groups of elements at once, that the outputs in both programs are the same function of the inputs.
KATML: An interactive theorem prover for Kleene Algebra with Tests
 University of Manchester
, 2003
"... Abstract. We describe an implementation of an interactive theorem prover for Kleene algebra with tests (KAT). The system is designed to reflect the natural style of reasoning with KAT that one finds in the literature. We illustrate its use with some examples. 1 ..."
Abstract

Cited by 13 (1 self)
 Add to MetaCart
Abstract. We describe an implementation of an interactive theorem prover for Kleene algebra with tests (KAT). The system is designed to reflect the natural style of reasoning with KAT that one finds in the literature. We illustrate its use with some examples. 1
2005b). Functional equivalence checking for verification of algebraic transformations on arrayintensive source code
 In L. Benini and N
"... Development of energy and performanceefficient embedded software is increasingly relying on application of complex transformations on the critical parts of the source code. Designers applying such nontrivial source code transformations are often faced with the problem of ensuring functional equi ..."
Abstract

Cited by 9 (4 self)
 Add to MetaCart
(Show Context)
Development of energy and performanceefficient embedded software is increasingly relying on application of complex transformations on the critical parts of the source code. Designers applying such nontrivial source code transformations are often faced with the problem of ensuring functional equivalence of the original and transformed programs. Currently they have to rely on incomplete and timeconsuming simulation. Formal automatic verification of the transformed program against the original is instead desirable. This calls for equivalence checking tools similar to the ones available for comparing digital circuits. We present such a tool to compare arrayintensive programs related through a combination of important global transformations like expression propagations, loop and algebraic transformations. When the transformed program fails to pass the equivalence check, the tool provides specific feedback on the possible locations of errors. 1
DataDriven Equivalence Checking
"... We present a data driven algorithm for equivalence checking of two loops. The algorithm infers simulation relations using data from test runs. Once a candidate simulation relation has been obtained, offtheshelf SMT solvers are used to check whether the simulation relation actually holds. The algor ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
(Show Context)
We present a data driven algorithm for equivalence checking of two loops. The algorithm infers simulation relations using data from test runs. Once a candidate simulation relation has been obtained, offtheshelf SMT solvers are used to check whether the simulation relation actually holds. The algorithm is sound: insufficient data will cause the proof to fail. We demonstrate a prototype implementation, called DDEC, of our algorithm, which is the first sound equivalence checker for loops written in x86 assembly. 1.
Enabling Loop Fusion and Tiling for Cache Performance by Fixing FusionPreventing Data Dependences
 In ICPP ’05: Proceedings of the 2005 International Conference on Parallel Processing
, 2005
"... This paper presents a new approach to enabling loop fusion and tiling for arbitrary affine loop nests. Given a set of multiple loop nests, we present techniques that automatically eliminate all the fusionpreventing dependences by means of loop tiling and array copying. Applying our techniques iter ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
(Show Context)
This paper presents a new approach to enabling loop fusion and tiling for arbitrary affine loop nests. Given a set of multiple loop nests, we present techniques that automatically eliminate all the fusionpreventing dependences by means of loop tiling and array copying. Applying our techniques iteratively to multiple loop nests yields a single loop nest that can be tiled for cache locality. Our approach handles LU, QR, Cholesky and Jacobi in a unified framework. Our experimental evaluation on an SGI Octane2 system shows that the benefit from the significantly reduced L1 and L2 cache misses has far more than offset the branching and loop control overhead introduced by our approach. 1
A PROOFTHEORETIC APPROACH TO MATHEMATICAL KNOWLEDGE MANAGEMENT
, 2007
"... Mathematics is an area of research that is forever growing. Definitions, theorems, axioms, and proofs are integral part of every area of mathematics. The relationships between these elements bring to light the elegant abstractions that bind even the most intricate aspects of math and science. As the ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
Mathematics is an area of research that is forever growing. Definitions, theorems, axioms, and proofs are integral part of every area of mathematics. The relationships between these elements bring to light the elegant abstractions that bind even the most intricate aspects of math and science. As the body of mathematics becomes larger and its relationships become richer, the organization of mathematical knowledge becomes more important and more difficult. This emerging area of research is referred to as mathematical knowledge management (MKM). The primary issues facing MKM were summarized by Buchberger, one of the organizers of the first Mathematical Knowledge Management Workshop [20]. • How do we retrieve mathematical knowledge from existing and future sources? • How do we build future mathematical knowledge bases? • How do we make the mathematical knowledge bases available to mathematicians? These questions have become particularly relevant with the growing power of and interest in automated theorem proving, using computer programs to prove
An Automatic Verification Technique for Loop and Data Reuse Transformations based on Geometric Modeling of Programs
, 2003
"... Optimizing programs by applying sourcetosource transformations is a prevalent practice among programmers. Particularly so, in the methodical embedded systems design frameworks, where the initial program is subject to a series of transformations to optimize computation and communication. In the con ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
Optimizing programs by applying sourcetosource transformations is a prevalent practice among programmers. Particularly so, in the methodical embedded systems design frameworks, where the initial program is subject to a series of transformations to optimize computation and communication. In the context of parallelization and custom memory design, such transformations are applied on the loop structures and index expressions of array variables in the program, more often manually than with a tool, leading to the nontrivial problem of checking their correctness. Applied transformations are semantics preserving if the transformed program is functionally equivalent to the initial program from the inputoutput point of view. In this work we present an automatic technique based on geometrical program modeling to formally check the functional equivalence of initial and transformed programs under loop and data reuse transformations. The verification is transformation oblivious needing no information either about the particular transformations that have been applied or the order in which they have been applied. Our technique also provides very useful diagnostics to locate the detected errors.