Doran Wilde

A Library for Doing Polyhedral Operations

Abstract The design and implementation of a library of C-code procedures to perform operations on rational polyhedra is described. The library supports intersection, union, difference, simplification in context, convex hull, affine image, affine preimage, and computation of dual forms. Since not all of these functions are closed over polyhedra, the library is extended to operate on finite unions of polyhedra. The major design decisions made during the implementation of the library are discussed. The data structure used for representing finite unions of polyhedra is developed and validity rules for the representation of polyhedra are derived. And finally, the algorithms used to implement the various functions in the library are presented.

Generation of Efficient Nested Loops from Polyhedra

Automatic parallelization in the polyhedral model is based on affine transformations from an original computation domain (iteration space) to a target space-time domain, often with a different transformation for each variable. Code generation is an often ignored step in this process that has a significant impact on the quality of the final code. It involves making a trade-off between code size and control code simplification/optimization. Previous methods of doing code generation are based on loop splitting, however they have nonoptimal behavior when working on parameterized programs. We present a general parameterized method for code generation based on dual representation of polyhedra. Our algorithm uses a simple recursion on the dimensions of the domains, and enables fine control over the tradeoff between code size and control overhead.

Parameterized polyhedra and their vertices

Algorithms specified for parametrically sized problems are more general purpose and more reusable than algorithms for fixed sized problems. For this reason, there is a need for representing and symbolically analyzing linearly parameterized algorithms. An important class of parallel algorithms can be described as systems of parameterized affine recurrence equations (PARE). In this representation, linearly parameterized polyhedra are used to describe the domains of variables. This paper describes an algorithm which computes the set of parameterized vertices of a polyhedron, given its representation as a system of parameterized inequalities. This provides an important tool for the symbolic analysis of the parameterized domains used to define variables and computation domains in PAREs. A library of operations on parameterized polyhedra based on the Polyhedral Library has been written in C and is freely distributed.

Memory Reuse Analysis in the Polyhedral Model

In the context of developing a compiler for a ALPHA, a functional data-parallel language based on systems of affine recurrence equations (SAREs), we address the problem of transforming scheduled single-assignment code to multiple assignment code. We show how the polyhedral model allows us to statically compute the lifetimes of program variables, and thus enables us to derive necessary and sufficient conditions for reusing memory.

Regular array synthesis using ALPHA

We report our current research in a computer assisted methodology for synthesizing regular array processors using the ALPHA language and design environment. The design process starts from an algorithmic level description of the function and finishes with a netlist of an array processor which performs the specified function. To illustrate the proposed approach, we present the design of an array processor to do polynomial division.<<ETX>>

Deriving imperative code from functional programs

Alpha is a data parallel functional language which has the capability of specifying algorithms at a very high level. Our ultimate objective is to generate efficient parallel imperative code from an Alpha program. In this paper, we discuss the related problem of generating efficient single processor imperative code. Analysis techniques that were developed for the synthesis of systolic arrays are extended and adapted for the compilation of functional programming languages. We also demonstrate how a transformational methodology can be used as a compilation engine to transform an Alpha program to a sequential form. C-code is then generated using a straightforward pretty printer from the sequential form Alpha program. The C-code may then be compiled to efficiently execute the program.

Efficient Tree-Based Feature Descriptor and Matching Algorithm

This paper presents the development of a new feature descriptor derived from previous work on the basis sparse-coding inspired similarity descriptor that provides smaller descriptor size, simpler computations, faster matching speed, and higher accuracy. The TreeBASIS descriptor algorithm uses a binary vocabulary tree that is computed offline using basis sparse-coding inspired similarity dictionary images derived from sparse coding and a test set of feature region images. The resulting tree is stored in memory for online high-speed searching for feature matching. During the online matching stage, a feature region image is binary quantized and the resulting quantized vector is passed into the basis sparse-coding inspired similarity tree. A Hamming distance is computed between the feature region images and the effectively descriptive basis sparse-coding inspired similarity dictionary images at the current node to determine the branch taken. The path the feature region image takes is saved as the descriptor, ...

Planning Continuous Curvature Paths Using Constructive Polylines

Previous methods for planning clothoid based continuous curvature paths aim at minimizing path length. However, minimal length paths are not always smooth, natural, and drivable. We discuss a method of generating clothoid-based trajectories using constructive polylines. The goal of the motion planner is to create a path for a large car-like vehicle in human driving environments, thus, the trajectories must be smooth, drivable, and natural enough to be used on roadways. We show several examples of trajectories developed for a DARPA Urban Challenge vehicle.

On deriving data parallel code from a functional program

We discuss a translation methodology for transforming a high level algorithmic specification written in ALPHA to an imperative data parallel language. We informally introduce the ALPHA language with the aid of an example and explain how it is adapted for doing static analysis and transformation. An ALPHA program can be naively compiled (P. Quinton et al., 1985) using applicative caching. Our compilation method makes incremental transformations on the abstract syntax tree of can ALPHA program in order to make efficiency and performance improvements over the naive code and optimize it for a given architecture. The compilation steps described include scheduling, alignment, partitioning, allocation, loop nest generation, and code generation and they are illustrated with an example.<<ETX>>

The naive execution of affine recurrence equations

In recognition of the fundamental relation between regular arrays and systems of affine recurrence equations, the ALPHA language was developed as the basis of a computer aided design methodology for regular array architectures. ALPHA is used to initially specify algorithms at a very high algorithmic level. Regular array architectures can then be derived from the algorithmic specification using a transformational approach supported by the ALPHA environment. This design methodology guarantees the final design to be correct by construction, assuming the initial algorithm was correct. In this paper, we address the problem of validating an initial specification. We demonstrate a translation methodology which compiles ALPHA into the imperative sequential language C. The C-code may then be compiled and executed to test the specification. We show how an ALPHA program can be naively implemented by viewing it as a set of monolithic arrays and their filing functions, implemented using applicative caching. This is the approach which is used by the translator. We discuss two problems that had to be solved before implementing the translator. The first is how to allocate 1-dimensional storage for a polyhedron, and the second is how to scan a polyhedron with nested loops.