Compile Time Comparisons Across Vintage and Modern Hardware

One of the things I enjoy doing when I get a vintage machine running is putting it through a real-world workload. Synthetic benchmarks are fine, but nothing tells you how a machine feels quite like watching it do actual work. For this test, I compiled a set of C++ libraries I wrote over the course of my career, roughly 33,000 lines of code, on every machine in my collection that could handle it.

What Was Measured

The benchmark is a straight compile of C++ source code into object files and archived into static libraries. No link times are included. This isolates the compiler and the CPU from other variables like disk I/O during linking or library resolution.

This is not a perfectly controlled benchmark. Different operating systems required different compilers. The oldest Sun machines ran newer GCC versions (2.8 and 2.9) cross-compiled or built from source. The Mac systems used whatever Apple ships with Xcode. The Raspberry Pis and Linux boxes used the GCC supplied by their respective distributions. Despite these differences, the results are directionally correct and paint a clear picture of relative performance across three decades of hardware.

The Results

The “vs IPC” column shows how much faster each machine is compared to the slowest machine tested, the SPARCstation IPC.

Observations

The M3 Max Is Absurd

The Apple MacBook Pro M3 Max compiled the entire codebase in 9.49 seconds. The SPARCstation IPC at the bottom of the chart took 513 seconds, over eight and a half minutes, to do the same work. That is a 54x difference spanning about 33 years of hardware evolution.

The SPARCstation 5 Stands Out

The SPARCstation 5 at 170MHz (highlighted in orange on the chart) is an interesting reference point. It was a very popular workstation in its day and sits right in the middle of the vintage machines. At 2 minutes 45 seconds it is about 17x slower than the M3 Max but meaningfully faster than the older SPARC machines below it. The jump from the SPARCstation 10 and 20 class machines down to the SS5 represents the move from the older generation SuperSPARC and HyperSPARC processors to the more efficient microSPARC and TurboSPARC designs.

SGI Machines Are Surprisingly Slow

The SGI Indigo and Indy both performed worse than you might expect given their reputations. The Indigo at 6 minutes 29 seconds sits among the slowest SPARC machines, and the Indy at 4 minutes 36 seconds is slower than the SPARCstation Voyager despite being a newer design. The SGI machines used MIPS processors and the IRIX compiler, so this is not strictly an apples-to-apples comparison, but it does reflect the real-world experience of compiling code on these systems.

Emulation Is Surprisingly Competitive

The QEMU-emulated SPARCstation 5 running on an Intel Nuc 11 compiled the code in 54.7 seconds. The real SPARCstation 5 at 170MHz took 165 seconds, making the emulated version 3x faster than the original hardware. This is a testament to how fast modern x86 hardware is. Even with the overhead of full system emulation, a modest modern machine handily outperforms the original.

The Raspberry Pi5 Holds Its Own

At 33 seconds, the Raspberry Pi5 is faster than every vintage workstation in the collection and is competitive with the Sun Ultra 5 at 400MHz. The Pi4 B at 55.7 seconds is also respectable, sitting right alongside the SunBlade 2000 at 63.4 seconds, a machine that cost thousands of dollars when it was new. A $60 single-board computer matching a high-end Sun workstation is a striking illustration of how far commodity hardware has come.

The Power uP Upgrades

Several machines appear with “Power uP” annotations, referring to aftermarket CPU upgrade boards that were popular in the Sun ecosystem. The SPARCstation IPX with a Power uP board cut its compile time from 7 minutes 41 seconds down to 6 minutes 31 seconds, a meaningful improvement. The SPARCstation 2 with a Power uP came in at 6 minutes flat versus an estimated 7 minutes 41 seconds stock. These upgrades helped but could not overcome the fundamental architectural limitations of the older platforms.

Methodology

Each machine compiled the same set of C++ source files using the make utility. Timing was measured using the wall clock time of the full compilation. The source code was stored on whatever local disk the machine had available, whether original SCSI, ZuluSCSI emulator, or modern SSD. Disk speed differences are minimal for compilation workloads of this size since the bottleneck is overwhelmingly CPU-bound.

The compilers varied by platform out of necessity. While this means the results are not a pure CPU benchmark, they do represent the real experience of sitting down at each machine and building software. That practical perspective is what makes this comparison interesting rather than a synthetic benchmark divorced from actual use.