Results 1  10
of
12
Modeling and Verifying Systems using a Logic of Counter Arithmetic with Lambda Expressions and Uninterpreted Functions
, 2002
"... In this paper, we present the logic of Counter arithmetic with Lambda expressions and Uninterpreted functions (CLU). CLU generalizes the logic of equality with uninterpreted functions (EUF) with constrained lambda expressions, ordering, and successor and predecessor functions. In addition to mod ..."
Abstract

Cited by 142 (43 self)
 Add to MetaCart
In this paper, we present the logic of Counter arithmetic with Lambda expressions and Uninterpreted functions (CLU). CLU generalizes the logic of equality with uninterpreted functions (EUF) with constrained lambda expressions, ordering, and successor and predecessor functions. In addition to modeling pipelined processors that EUF has proved useful for, CLU can be used to model many infinitestate systems including those with infinite memories, finite and infinite queues including lossy channels, and networks of identical processes. Even with this richer expressive power, the validity of a CLU formula can be efficiently decided by translating it to a propositional formula, and then using Boolean methods to check validity. We give theoretical and empirical evidence for the efficiency of our decision procedure. We also describe verification techniques that we have used on a variety of systems, including an outoforder execution unit and the loadstore unit of an industrial microprocessor.
On Solving Presburger and Linear Arithmetic with SAT
 In Proc. of Formal Methods in ComputerAided Design (FMCAD 2002), LNCS
, 2002
"... We show a reduction to propositional logic from quantifierfree Presburger arithmetic, and disjunctive linear arithmetic, based on FourierMotzkin elimination. While the complexity of this procedure is not better than competing techniques, it has practical advantages in solving verification problems ..."
Abstract

Cited by 26 (2 self)
 Add to MetaCart
We show a reduction to propositional logic from quantifierfree Presburger arithmetic, and disjunctive linear arithmetic, based on FourierMotzkin elimination. While the complexity of this procedure is not better than competing techniques, it has practical advantages in solving verification problems. It also promotes the option of deciding a combination of theories by reducing them to this logic.
An Efficient Code Generation Technique for Tiled Iteration Spaces
 IEEE Transactions on Parallel and Distributed Systems
, 2003
"... This paper presents a novel approach for the problem of generating tiled code for nested forloops, transformed by a tiling transformation. Tiling or supernode transformation has been widely used to improve locality in multilevel memory hierarchies, as well as to efficiently execute loops onto para ..."
Abstract

Cited by 12 (5 self)
 Add to MetaCart
This paper presents a novel approach for the problem of generating tiled code for nested forloops, transformed by a tiling transformation. Tiling or supernode transformation has been widely used to improve locality in multilevel memory hierarchies, as well as to efficiently execute loops onto parallel architectures. However, automatic code generation for tiled loops can be a very complex compiler work, especially when nonrectangular tile shapes and iteration space bounds are concerned. Our method considerably enhances previous work on rewriting tiled loops, by considering parallelepiped tiles and arbitrary iteration space shapes. In order to generate tiled code, we first enumerate all tiles containing points within the iteration space and second sweep all points within each tile. For the first subproblem, 1 we refine upon previous results concerning the computation of new loop bounds of an iteration space that has been transformed by a nonunimodular transformation. For the second subproblem, we transform the initial parallelepiped tile into a rectangular one, in order to generate efficient code with the aid of a nonunimodular transformation matrix and its Hermite Normal Form (HNF). Experimental results show that the proposed method significantly accelerates the compilation process and generates much more efficient code.
On Reducing Overhead in Loops
, 1996
"... Reordering transformations in the framework of linear loop transformations tend to generate complex loop nests that scan the transformed iteration spaces. These loop nests have an incurred overhead due to complex loop bounds and guards that guarantee the correct execution of the operations in the re ..."
Abstract

Cited by 10 (3 self)
 Add to MetaCart
Reordering transformations in the framework of linear loop transformations tend to generate complex loop nests that scan the transformed iteration spaces. These loop nests have an incurred overhead due to complex loop bounds and guards that guarantee the correct execution of the operations in the reshaped iteration space. In this paper we discuss several techniques for reducing overhead in the resulting loop structures. In particular, we describe two topics: (1) Simplifying loop bounds, and (2) removing affine IFstatements from loops. The objective is to isolate the part of the iteration space of the original loop in which the bounds take simpler forms, or in which the condition is satisfied. The main technical tool for determining this subspace is FourierMotzkin elimination. We show an easy way to generate code for scanning the different parts of an iteration space that have been isolated in this way. We present our techniques as a number of elementary transformation steps. Since th...
Automatic Code Generation for Executing Tiled Nested Loops Onto Parallel Architectures
, 2002
"... This paper presents a novel approach for the problem of generating tiled code for nested forloops using a tiling transformation. Tiling or supernode transformation has been widely used to improve locality in multilevel memory hierarchies as well as to efficiently execute loops onto nonuniform mem ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
This paper presents a novel approach for the problem of generating tiled code for nested forloops using a tiling transformation. Tiling or supernode transformation has been widely used to improve locality in multilevel memory hierarchies as well as to efficiently execute loops onto nonuniform memory access architectures. However, automatic code generation for tiled loops can be a very complex compiler work due to nonrectangular tile shapes and iteration space bounds. Our method considerably enhances previous work on rewriting tiled loops by considering parallelepiped tiles and arbitrary iteration space shapes. The complexity of code generation for tiling transformation is now reduced to the complexity of code generation for any linear transformation. Experimental results which compare all so far presented approaches, show that the proposed approach for generating tiled code is significantly accelerated.
SDSAT: Tight Integration of Small Domain Encoding and Lazy Approaches in a Separation Logic Solver
 In Proc. TACASâ€™06, volume 3920 of LNCS
, 2006
"... Existing difference logic (DL) solvers can be broadly classified as eager or lazy, each with its own merits and demerits. We propose a novel difference logic solver SDSAT that combines the strengths of both these approaches and provides a robust performance over a wide set of benchmarks. The solver ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
Existing difference logic (DL) solvers can be broadly classified as eager or lazy, each with its own merits and demerits. We propose a novel difference logic solver SDSAT that combines the strengths of both these approaches and provides a robust performance over a wide set of benchmarks. The solver SDSAT works in two phases: allocation and solve. In the allocation phase, it allocates nonuniform adequate ranges for variables appearing in difference predicates. This phase is similar to previous small domain encoding approaches, but uses a novel algorithm NuSMOD with 12 orders of magnitude improvement in performance and smaller ranges for variables. Furthermore, the difference logic formula is not transformed into an equisatisfiable Boolean formula in a single step, but rather done lazily in the following phase. In the solve phase, SDSAT uses a lazy refinement approach to search for a satisfying model within the allocated ranges. Thus, any partially DLtheory consistent model can be discarded if it cannot be satisfied within the allocated ranges. Note the crucial difference: in eager approaches, such a partially consistent model is not allowed in the first place, while in lazy approaches such a model is never discarded. Moreover, we dynamically refine the allocated ranges and search for a feasible solution within the updated ranges. This combined approach benefits from both the smaller search space (as in eager approaches) and also from the theoryspecific graphbased algorithms (characteristic of lazy approaches). Experimental results show that our method is robust and always better than or comparable to stateofthe art solvers using similar eager or lazy techniques.
Multitransformations: Code Generation and Validity
, 1995
"... In this paper we present a generalization of the framework of unimodular loop transformations for parallelizing compilers, called multitransformations. Multitransformations consist of applying a different unimodular transformation to the iteration space of each statement in the loop body, and inclu ..."
Abstract

Cited by 4 (4 self)
 Add to MetaCart
In this paper we present a generalization of the framework of unimodular loop transformations for parallelizing compilers, called multitransformations. Multitransformations consist of applying a different unimodular transformation to the iteration space of each statement in the loop body, and include also alignments. Two key aspects are considered in this paper: the generation of efficient code that traverses the different transformed iteration spaces and the test to decide the legality of the multitransformation. Some examples are used in the paper that show the usefulness of multitransformations. In parallelizing compilers for sharedmemory they allow an easy exploitation of parallelism; for distributedmemory multiprocessors they allow the generation of code that follows the ownercomputes rule and exploits locality of references.
On the Validity Problem for Unimodular Transformations
, 1994
"... In this paper a new approach to the validity problem of unimodular transformations is proposed. First, we define a representation of data dependences by means of convex polytopes. Second, it is shown how this representation can be used to test the validity of unimodular transformations. This method ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
In this paper a new approach to the validity problem of unimodular transformations is proposed. First, we define a representation of data dependences by means of convex polytopes. Second, it is shown how this representation can be used to test the validity of unimodular transformations. This method is strictly more powerful than methods based on dependence direction vectors, as proposed by Wolfe, or interval vector, as proposed by Wolf and Lam. We show how our method can be extended to cover the situations where affine guards are present in the loop body, where multiple transformations or displacements are used to transform the loop, as well.
Code Generation Methods for tiling transformations
 Journal of Information Science and Engineering
, 2002
"... Tiling or supernode transformation has been widely used to improve locality in multilevel memory hierarchies, as well as to efficiently execute loops onto parallel architectures. However, automatic code generation for tiled loops can be a very complex compiler work due to nonrectangular tile shape ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Tiling or supernode transformation has been widely used to improve locality in multilevel memory hierarchies, as well as to efficiently execute loops onto parallel architectures. However, automatic code generation for tiled loops can be a very complex compiler work due to nonrectangular tile shapes and arbitrary iteration space bounds. In this paper, we first survey code generation methods for nested loops which are transformed using nonunimodular transformations. All methods are based on FourierMotzkin (FM) elimination. Next, we consider and enhance previous work on rewriting tiled loops by considering parallelepiped tiles and arbitrary iteration space shapes. In order to generate tiled code, all methods first enumerate the tiles containing points within the iteration space, and second, sweep the points within each tile. For the first, we extend previous work in order to access all tile origins correctly, while for the latter, we propose the transformation of the initial parallelepiped tile iteration space into a rectangular one, so as to generate code efficiently with the aid of a nonunimodular transformation matrix and its Hermite Normal Form (HNF). The resulting systems of inequalities are much simpler than those appeared in bibliography; thus their solutions are more efficiently determined using the FM elimination. Experimental results which compare all presented approaches, show that the proposed method for generating tiled code is significantly accelerated, thus rewriting any $n$D tiled loop in a much more efficient and direct way.