Linux and the Alpha

Part 2 brings us optimization techniques for speeding up code to get the best performance from your Alpha or other RISC processor.

In this article, I will discuss
techniques to optimize code for platforms running Linux on Alpha
processors. It is based on four years of experience with the Alpha
architecture. The primary lesson from this experience is that, for
many applications, the memory system, and not the processor itself,
is the primary bottleneck. For this reason, most techniques are
targeted at avoiding the memory system bottleneck. Since the gap
between processor and memory system speed is large, these
techniques achieve performance improvements of up to 1700%. While
the focus is on the Alpha architecture, many of the covered
techniques are readily applicable to other RISC processors and even
modern CISC CPUs.

The tricky part in discussing how the same techniques work on
other architectures is that we want to do this without igniting a
war over which CPU architecture is the “best” or the “fastest”.
Such terms are, to a good degree, meaningless, since they can be
applied usefully relative to a given problem only. For this reason,
performance results are presented as follows: for the Alpha we
present both absolute and relative results. The absolute numbers
are useful to give a concrete feel for how fast the code is. The
relative results (i.e., speed ups) are what tell us how well a
given technique works. Where meaningful, we also list the speed up
(but not the absolute performance) achieved on a Pentium Pro-based
system. Only listing speed up for the Pentium Pro case makes it
impossible to tell which system was faster on a given problem while
still allowing us to compare the relative benefits. (To avoid any
misconception: this arrangement was not chosen because the Alpha
performed poorly; the author has been using Alphas for some time
now and is generally pleased with the performance level they
achieve.)

Since an architecture per se doesn't perform at all, let us
be a bit more specific about the systems used for the
measurements:

Alpha system: The Alpha system was an AlphaStation
600 5/333 (aka Alcor). It has a 333MHz 21164 processor with 4MB of
third-level cache and 64MB of main-memory. While a nice (and very
expensive) box, it is by no means the latest and greatest of the
available Alpha systems. At the time of this writing, much faster
and much cheaper 500MHz systems have already been around for a
while.

Pentium Pro system: The x86 system was a Gateway
2000 with a Pentium Pro processor with 32MB of main memory and
256KB of second-level cache. For clarity, this system is referred
to as “P6” during the remainder of this section.

Both the Alpha and the P6 systems were running Red Hat 4.0
with kernel version 2.0.18. The compiler used was
gcc version 2.7.2. On the Alpha,
option -O2 was used (with this version of gcc,
using an option setting of -O3 or higher
generally results in slower code.). On the P6, options
-O6 and -m486 were
used.

It is also illustrative to compare gcc to commercial Alpha
compilers, such as Digital's GEM C compiler. The GEM C compiler
usually generates somewhat better code but now and then it creates
code much faster than gcc's code (this usually happens on
floating-point intensive code). For this reason, some of the
measurements also include the results obtained with GEM C. This
compiler was invoked as:

cc -migrate -O4 -tune ev5 -std1 -non_shared

It's not clear which version of the compiler it was—it came
with Digital UNIX version 3.2.

Avoiding Integer Division

The Alpha architecture does not provide an integer division
instruction. The rationale for this is:

Such operations are relatively rare.

Division is fundamentally of an iterative nature,
so implementing it in hardware is not all that much faster than a
good software implementation. (See Reference 1.)

Nevertheless, there are important routines that depend on
integer division. Hash-tables are a good example as computing a
hash-table index typically involves dividing by an integer prime
constant.

There are basically two ways to avoid integer division.
Either the integer division is replaced by a floating-point
division or, if the division is by a constant, it is possible to
replace the division by a multiplication with a constant, a shift
and a correction by one (which isn't always necessary).
Floating-point division may sound like a bad idea, but the Alpha
has a very fast floating-point unit, and since a 32-bit integer
easily fits into a double without a loss of precision, it works
surprisingly well. Replacing a division by a constant with a
multiplication by the inverse is certainly faster, although it's
also a bit tricky since care must be taken that the result is
always accurate (off-by-one errors are particularly common).
Fortunately, for compile-time constants, gcc takes care of this
without help.

To illustrate the effect this can have, we measured how long
it takes to look up all symbols in the standard C library (libc.so)
using the ELF hash-table look-up algorithm (which involves one
integer division by a prime constant). With integer division,
roughly 1.2 million look ups per second can be performed. Using a
double multiplication by the inverse of the divisor instead brings
this number up to 1.95 million look ups per second (62%
improvement). Using integer multiplication instead gives the best
performance of 2.05 million lookups per second (70% improvement).
Since the performance difference between the double and the integer
multiply-by-inverse version isn't all that big, it's usually better
to use the floating-point version. This works perfectly well, as
long as the operands fit in 52 bits, and avoids having to worry
about off-by-one errors.

Trending Topics

Upcoming Webinar

Getting Started with DevOps - Including New Data on IT Performance from Puppet Labs 2015 State of DevOps Report

August 27, 2015
12:00 PM CDT

DevOps represents a profound change from the way most IT departments have traditionally worked: from siloed teams and high-anxiety releases to everyone collaborating on uneventful and more frequent releases of higher-quality code. It doesn't matter how large or small an organization is, or even whether it's historically slow moving or risk averse — there are ways to adopt DevOps sanely, and get measurable results in just weeks.