Deborah Whitfield

An approach for exploring code improving transformations

Although code transformations are routinely applied to improve the performance of programs for both scalar and parallel machines, the properties of code-improving transformations are not well understood. In this article we present a framework that enables the exploration, both analytically and experimentally, of properties of code-improving transformations. The major component of the framework is a specification language, Gospel, for expressing the conditions needed to safely apply a transformation and the actions required to change the code to implement the transformation. The framework includes a technique that facilitates an analytical investigation of code-improving transformations using the Gospel specifications. It also contains a tool, Genesis, that automatically produces a transformer that implements the transformations specified in Gospel. We demonstrate the usefulness of the framework by exploring the enabling and disabling properties of transformations. We first present analytical results on the enabling and disabling properties of a set of code transformations, including both traditional and parallelizing transformations, and then describe experimental results showing the types of transformations and the enabling and disabling interactions actually found in a set of programs.

An approach to ordering optimizing transformations

As an approach to deriving an application order of optimizing transformations, a framework is developed for examining the interactions of the transformations. The framework is based on an axiomatic specification technique and includes both pre-conditions and post conditions that must exist before and after applying optimizations. For a selected set of optimizations, the framework is used to determine those interactions among the optimizations that can create conditions and those that can destroy conditions for applying other optimizations. From these interactions, an application order is derived to obtain the potential benefits of the optimizations that can be applied to a program. In some cases, the ordering of a pair of optimizations is unambiguous in that one optimization can either create or destroy the conditions for the other. In the few cases where there is a cyclic interaction, the ordering is resolved based on the perceived importance of the two optimizations.

Automatic generation of global optimizers

This research has developed an optimizer generator that automatically produces optimizers from specifications. Code optimizations are expressed using a specification language designed for both traditional and parallelizing optimization, which require global dependence conditions. Numerous optimizers have been produced from a prototype implementation of the generator. The quality of code produced using the generated optimizers compares favorably with that produced by hand coded optimizers. The generator can be used as a phase in a compiler or as an experimental tool to determine the effects of various optimization and to tailor optimization. Experiments indicate that optimization interact in practice and that different orderings of optimization are needed for different code segments of the same program. Experiments found that the cost-benefit ratio of some optimizations is quite large and in some cases can be reduced by careful specifications of the optimizations or different implementations.

Investigating Properties of Code Transformations

Creating highly optimized code for parallel machines is a difficult task, as the efficiency of the transformed the code depends of the types of tranformations applied.

The design and implementation of Genesis

Although code optimizations are necessary to parallelize code, few guidelines exist for determining when and where to apply optimizations to produce the most efficient code. The order of applying optimizations can also have an impact on the efficiency of the final target code. However, determining the appropriate optimizations is difficult due to the complex interactions among the optimizations, scheduler and architecture. To aid in selecting appropriate optimizations, an optimizer generator (Genesis) is presented that produces an optimizer from specifications of optimizations. This paper describes the design and implementation of Genesis and demonstrates how such a generator could be used by optimizer designers. Some experiences with the generator are also described.

Constructing random polygons

The construction of random polygons has been used in psychological research and for the testing of algorithms. With the increased popularity of client-side vector based graphics in the web browser such as seen in Flash and SVG, as well as the newly introduced <canvas> tag in HTML5.0, the use of random shapes for creation of scenes for animation and interactive art requires the construction of random polygons. A natural question, then, is how to generate random polygons in a way which is computationally efficient (particularly in a resource limited environment such as the web browser). This paper presents a random polygon algorithm (RPA) that generates polygons that are random and representative of the class of all n-gons in O(n²logn) time. Our algorithm differs from other approaches in that the vertices are generated randomly, the algorithm is inclusive (i.e. each polygon has a non-zero probability to be constructed), and it runs efficiently in polynomial time.

Assessing computer science programs: what have we learned

1. SUMMARY How does a department evaluate the effectiveness of its major programs in computer science? In years past it might have been done rather informally by faculty members having a sense of what their students are learning and measuring that against curriculum guidelines developed by national organizations such as ACM and the IEEE Computer Society. Or, maybe faculty members might have made that judgment by the types of jobs their students were obtaining right after they graduate or the number of students who would go on to graduate school in computer science. Nowadays, however, because of both internal and external forces, computer science departments are introducing formal processes. These involve articulating objectives (or goals) and outcomes for their programs and using a variety of instruments to measure success in meeting those objectives and outcomes, all with the idea of using the results to improve the program.