Martin Edward Hopkins

A methodology for the real world

Register allocation may be viewed as a graph coloring problem. Each node in the graph stands for a computed quantity that resides in a machine register, and two nodes are connected by an edge if the quantities interfere with each other, that is, if they are simultaneously live at some point in the object program. This approach, though mentioned in the literature, was never implemented before. Preliminary results of an experimental implementation in a PL/I optimizing compiler suggest that global register allocation approaching that of hand-coded assembly language may be attainable.

Exploiting instruction level parallelism in processors by caching scheduled groups

Modern processors employ a large amount of hardware to dynamically detect parallelism in single-threaded programs and maintain the sequential semantics implied by these programs. The complexity of some of this hardware diminishes the gains due to parallelism because of longer clock period or increased pipeline latency of the machine.In this paper we propose a processor implementation which dynamically schedules groups of instructions while executing them on a fast simple engine and caches them for repeated execution on a fast VLIW-type engine. Our experiments show that scheduling groups spanning several basic blocks and caching these scheduled groups results in significant performance gain over fill buffer approaches for a standard VLIW cache.This concept, which we call DIF (Dynamic Instruction Formatting), unifies and extends principles underlying several schemes being proposed today to reduce superscalar processor complexity. This paper examines various issues in designing such a processor and presents results of experiments using trace-driven simulation of SPECint95 benchmark programs.

An overview of the PL.8 compiler

The PL.8 compiler accepts multiple source languages and produces high quality object code for several different machines. The strategy used is to first do a simple translation of the source program to a low level intermediate language. Global optimization and register allocation are then used to improve code rather than relying on special case code selection.

A case for the GOTO

In recent years there has been much controversy over the use of the <underline>goto</underline> statement. This paper, while acknowledging that <underline>goto</underline> has been used too often, presents the case for its retention in current and future programming languages.

A perspective on the 801/Reduced Instruction Set Computer

From the earliest days of computers until the early 1970s, the trend in computer architecture was toward increasing complexity. This complexity revealed itself through the introduction of new instructions that matched the application areas. Microcode was an implementation technique that greatly facilitated this trend; thus, most computers were implemented using microcode. In 1975, work began at the Thomas J. Watson Research Center on an experimental minicomputer. This project, termed the 801 project, questioned the trend toward complexity in computer architecture. It was observed that most of the complex instructions were seldom used. Thus, a computer could be designed with only simple instructions without drastically increasing the path length or number of instructions required to implement an application. This made it possible to implement a machine without resorting to microcode, which improved performance. This paper described the background and evolution of these ideas in the context of the 801 experimental minicomputer project.

Problems of PL/I for system programming

A group within the Computer Science Department of the IBM T. J. Watson Research Center is now engaged in the design and development of System/A, an experimental operating system to support a variety of user activities with multiprocessing hardware. PL/I has been chosen as the system implementation language. Work with the language has shown that it is very good for system programming. However, there are problems. A number of minor annoyances can be circumvented rather easily but there are a few more basic problems which often stem from the fundamental concepts of PL/I.

XIL and YIL: the intermediate languages of TOBEY

Typically, the choice of intermediate representation by a particular compiler implementation seeks to address a specific goal. The intermediate language of the TOBEY compilers, XIL, was initially chosen to facilitate the production of highly optimal scalar code, yet, it was easily extended to a higher level form YIL in order to support a new suite of optimizations which in most existing compilers are done at the level of source to source translation. In this paper we will discuss those design features of XIL that were important factors in the production of optimal scalar code. In addition we will demonstrate how the strength of the YIL abstraction lay in its ability to access the underlying low level representation.