Benchmarking C, C++, Go, and Rust: A Deep Dive into Compilation and Runtime Performance

Benchmark Setup

To evaluate these languages, we used:

Hyperfine: To measure compilation times.
Perf Stat: To analyze runtime performance metrics like execution time, CPU utilization, instructions, cycles, branch behavior, and microarchitecture bottlenecks.

The programs were simple “empty loop” implementations, ensuring that the benchmarks focused on raw language and compiler performance without external dependencies.

1. Compilation Time: How Fast Can You Build?

Key Metrics

Mean Time: Average time taken to compile the program.
Variance (σ): Indicates consistency in compilation time.

Results

Language	Mean Time (ms) ± σ	Relative Speed
C	24.6 ms ± 0.9 ms	Fastest
Go	27.1 ms ± 1.5 ms	~1.10× slower than C
Rust	107.5 ms ± 1.7 ms	~4.36× slower than C
C++	249.7 ms ± 2.5 ms	~10.13× slower than C

Analysis

C is the fastest at 24.6 ms, thanks to its simplicity and mature compiler optimizations.
Go is slightly slower (27.1 ms), likely due to additional runtime setup during compilation.
Rust takes significantly longer (107.5 ms) due to its complex type system, borrow checker, and LLVM-based backend.
C++ is the slowest by far (249.7 ms), likely because of template instantiation and heavier compiler workloads.

Takeaway

If fast compilation is critical—for example, in rapid prototyping or large-scale builds—C is the clear winner. However, if you’re willing to trade some compilation speed for modern features, Go is a close second.

2. Runtime Performance: How Efficient Are the Compiled Programs?

Key Metrics

We evaluated runtime performance based on:

Execution Time: Direct measure of how long the program takes to run.
Task Clock and CPU Utilization: Efficiency of CPU resource usage.
Instructions and Cycles: Code efficiency and instruction throughput.
Branch Behavior: Control flow efficiency.
Page Faults: Memory access patterns.
Top-Down Microarchitecture Analysis: Pipeline bottlenecks.

2.1 Execution Time

Language	Execution Time (µs)
Go	327 ns (avg)
Rust	2.8 µs (avg)
C	2.5 µs (avg)
C++	2 µs (avg)

Go dominates with an astonishingly low execution time of 327 ns, making it the fastest at runtime for this specific benchmark.
C++ is close behind (2 µs), but still slower than Go.
Rust is significantly slower (2.8 µs), likely due to runtime checks or inefficiencies in loop handling.
C is slightly slower than C++ (2.5 µs), possibly due to less aggressive optimizations compared to Go or C++.

2.2 Task Clock and CPU Utilization

Language	Task Clock (msec)	CPUs Utilized (%)
Go	0.63	73.7%
Rust	0.32	53.6%
C	0.24	51.1%
C++	0.67	72.8%

Go achieves a good balance between task-clock time and CPU utilization, indicating efficient execution.
C++ has slightly lower CPU utilization (72.8%) but also the highest task-clock time (0.67 msec), suggesting inefficiencies or runtime overhead.

2.3 Instructions and Cycles

Language	Instructions	Cycles	IPC (Instructions per Cycle)
Go	2,245,392	2,419,181	0.77
Rust	1,498,497	1,285,536	1.02
C	942,153	964,819	0.96
C++	3,403,317	2,711,607	1.22

C++ executes the most instructions and cycles, likely due to additional abstractions or runtime checks.
Go has the lowest IPC (0.77), indicating inefficiencies in instruction throughput.
Rust and C achieve higher IPC (1.02 and 0.96, respectively), reflecting better pipeline utilization.

2.4 Branch Behavior

Language	Branches	Branch Misses	Branch Miss Rate (%)
Go	481,304	6,327	1.29%
Rust	328,277	7,004	2.15%
C	211,875	4,110	1.94%
C++	679,525	14,941	2.20%

Go has the lowest branch miss rate (1.29%), indicating highly efficient branch prediction.
C++ has the highest branch miss rate (2.20%) and the most branches, which can degrade performance.

2.5 Page Faults

Language	Page Faults
C	62
Rust	76
Go	205
C++	128

C has the fewest page faults (62), reflecting minimal memory usage.
Go has the highest page faults (205), likely due to runtime overhead or garbage collection.

2.6 Top-Down Microarchitecture Analysis

Retiring (%)

Language	Retiring (%)
Go	24.2%
Rust	26.0%
C	26.4%
C++	29.2%

Frontend Bound (%)

Language	Frontend Bound (%)
Go	41.2%
Rust	43.6%
C	44.8%
C++	32.7%

Backend Bound (%)

Language	Backend Bound (%)
Go	25.9%
Rust	19.0%
C	18.4%
C++	24.4%

Analysis

Go has balanced retiring, frontend, and backend behavior, though it is slightly frontend-bound.
C++ has the highest retiring percentage (29.2%) but is less frontend-bound (32.7%), indicating efficient instruction retirement.
Rust and C show similar patterns, with Rust being slightly more frontend-bound.

Summary of Findings

Compilation Time

Winner: C (fastest and most consistent).
Runner-Up: Go (slightly slower than C).
Loser: C++ (slowest by far).

Runtime Performance

Winner: Go (fastest execution time and efficient branch prediction).
Runner-Up: C++ (close second in execution time).
Loser: C (slower execution time).

Conclusion

Each language has its strengths and weaknesses, and the best choice depends on your priorities:

If compilation speed is critical:
Use C for its lightning-fast compilation times.
If runtime performance is critical:
Use Go for its blazing-fast execution and efficient branch prediction.
If you need modern features and safety:
Use Rust for its robust type system and memory safety guarantees, despite its slower compilation.
If you need advanced abstractions and templates:
Use C++, but be prepared for slower compilation and potentially higher runtime overhead.

Ultimately, the “best” language depends on your specific use case. For small, performance-critical tasks, Go shines. For large-scale systems where safety and modern features are paramount, Rust is a strong contender. And for quick-and-dirty scripts or embedded systems, C remains unbeatable.

Global Metrics Comparison

Metric	C	Go	Rust	C++
Compilation Time	🥇 Fastest	🥈 Close second	🥉 Slower	❌ Slowest
Runtime Execution Time	❌ Slowest	🥇 Fastest	🥉 Slower	🥈 Close second
Branch Prediction	🥈 Good	🥇 Best	🥉 Moderate	❌ Worst
CPU Utilization	❌ Low	🥇 High	🥈 Moderate	🥉 Moderate
Memory Usage (Page Faults)	🥇 Minimal	❌ Highest	🥈 Moderate	🥉 Moderate

Global Winner: Go

When considering both compilation time and runtime performance , Go emerges as the global winner . Here's why:

Runtime Performance :
- Go is the fastest at runtime with an average execution time of 327 ns —far ahead of its competitors.
- It has the best branch prediction efficiency (1.29% miss rate ) and high CPU utilization (73.7% ).
Compilation Time :
- While not the absolute fastest, Go’s compilation time (27.1 ms ) is very close to C’s (24.6 ms ) and significantly faster than Rust and C++.
Balance of Metrics :
- Go strikes a great balance between compilation speed and runtime efficiency, making it suitable for both development speed and production performance.

Why Not the Others?

C :
- While C wins in compilation speed, its runtime performance lags behind Go and even C++. Its lower CPU utilization and higher frontend-bound percentage indicate inefficiencies in modern workloads.
Rust :
- Rust’s runtime performance is decent but not exceptional. Its slow compilation time and higher frontend-bound percentage make it less competitive globally.
C++ :
- C++ performs well at runtime but suffers from extremely slow compilation times. Its higher branch miss rate and backend-bound percentage also indicate inefficiencies.

Final Verdict

The global winner is Go . It excels in runtime performance while maintaining reasonable compilation speed, making it the most versatile choice for a wide range of use cases.

However, if your project has specific needs (e.g., minimal memory usage or advanced abstractions), you might prefer C , Rust , or C++ depending on the context.

Final Answer:

Go is the global winner , balancing both compilation speed and runtime performance effectively.

IMAGES

HYPERFINE

PERF

RUST

GO

CPP

C

Benchmarking C, C++, Go, and Rust: A Deep Dive into Compilation and Runtime Performance

kant