|
C. Robert Morgan,
Senior Consulting Engineer,
Technical Program
Manager, Core Technology Group
The complexity of high-performance systems and the
need for ever-increased performance to be gained from
those systems creates a challenge for engineers, one that
requires both experience and innovation in the
development of software tools. The papers in this issue
of the Journal are a few selected examples of the
work performed within Compaq and by researchers worldwide
to advance the state of the art. In fact, Compaq supports
relevant research in programming languages and tools.
Compaq has been developing high-performance tools for
more than thirty years, starting with the Fortran
compiler for the DIGITAL PDP-10, introduced in 1967.
Later compilers and tools for VAX computer systems,
introduced in 1977, made the VAX system one of the most
usable in history. The compilers and debugger for VAX/VMS
are exemplary. With the introduction of the VAX successor
in 1992, the 64-bit RISC Alpha systems, Compaq has
continued the tradition of developing advanced tools that
accelerate application performance and usability for
system users. The papers, however, represent not only the
work of Compaq engineers but also that of researchers and
academics who are working on problems and advanced
techniques of interest to Compaq.
The paper on characterization of system workloads by
Casmira, Hunter, and Kaeli addresses the capture of basic
data needed for the development of tools and
high-performance applications. The authors’ work
focuses on generating accurate profile and trace data on
machines running the Windows NT operating system.
Profiling describes the point in the program that is most
frequently executed. Tracing describes the commonly
executed sequence of instructions. In addition to helping
developers build more efficient applications, this
information assists designers and implementers of future
Windows NT systems.
Every compiler consists of two components: the front
end, which analyzes the specific language, and the back
end, which generates optimized instructions for the
target machine. An efficient compiler is a balance of
both components. As languages such as C++ evolve, the
compiler front end must also evolve to keep pace. C++ has
now been standardized, so evolutionary changes will
lessen. However, compiler developers must continue to
improve front-end techniques for implementing the
language to ensure ever better application performance.
An important feature of C++ compiler development is C++
templates. Templates may be implemented in multiple ways,
with varying effects on application programs. The paper
by Itzkowitz and Foltan describes Compaq’s efficient
implementation of templates. On a related subject,
Rotithor, Harris, and Davis describe a systematic
approach Compaq has developed for monitoring and
improving C++ compiler performance to minimize cost and
maximize function and reliability.
Improved optimization techniques for compiler back
ends are presented in three papers. In the first of
these, Reinig addresses the requirement in an optimizing
compiler for an accurate description of the variables and
fields that may be changed by an assignment operation,
and describes an efficient technique used in the C/C++
compilers for gathering this information. Sweany, Carr,
and Huber describe techniques for increasing execution
speed in processors like the Alpha that issue multiple
instructions simultaneously. The technique reorders the
instructions in the program to increase the number of
instructions that are simultaneously issued. Maximizing
the performance of multiprocessor systems is the subject
of the paper by Hall et al., which was previously
published in IEEE Computer and updated with an
addendum for this issue. The authors describe the SUIF
compiler, which represents some of the best research in
this area and has become the basis of one part of the
ARPA compiler infrastructure project. Compaq assisted
researchers by providing the DIGITAL Fortran compiler
front end and an AlphaServer 8400 system.
As compilers become more effective in increasing
application program performance, the ability to debug the
programs becomes more difficult. The difficulty arises
because the compiler gains efficiency by reordering and
eliminating instructions. Consequently, the instructions
for an application program are not easily identifiable as
part of any particular statement. The debugger cannot
always report to the application program where variables
are stored or what statement is currently being executed.
Application programmers have two choices: Debug an
unoptimized version of the program or find some other
technique for determining the state of the program. The
paper by Brender, Nelson, and Arsenault reports an
advanced development project at Compaq to provide
techniques for the debugger to discover a more accurate
image of the state of the program. These techniques are
currently being added to Compaq debuggers.
One of the problems that tool developers face is
increasing tool reliability. Tool developers, therefore,
test the code. However, developers are often biased; they
know how their programs operate, and they test certain
aspects of the code but not others. The paper by McKeeman
describes a technique called differential testing that
generates correct random tests of tools such as
compilers. The random nature of the tests removes the
developers’ bias. The tool can be used for two
purposes: to improve existing tools and to compare the
reliability of competitive tools.
The High Performance Technical Computing Group and the
Core Technology Group within Compaq are pleased to help
develop this issue of the Journal. Studying the
work performed within Compaq and by other researchers
worldwide is one way that we remain at the cutting edge
of technology of programming language, compiler, and
programming tool research.
Bob Morgan
|
|
