Overview

Performance comparison between NitroPascal (releasefast optimization) and Delphi (Release mode) using the NPBench micro-benchmark suite.

Test Environment:

• Platform: Windows x64
• Date: October 17, 2025
• NitroPascal: releasefast optimization mode
• Delphi: Release mode with full optimizations

Benchmark Suite

NPBench consists of three micro-benchmarks designed to measure different aspects of compiler performance:

1. String Concatenation (string_concat_1k)

Repeatedly concatenates a single character to build a 1KB string:

LStr := '';
for LIndex := 1 to 1024 do
 LStr := LStr + 'x';

Measures: String memory allocation, copy operations, runtime library efficiency
Data processed: 1,024 bytes per iteration

2. Array Sum (array_sum_10m)

Computes running sum over 10 million integers with array writes:

LSum := 0;
for LIndex := 1 to 10,000,000 do
begin
 LSum := LSum + LIndex;
 LArray[LIndex mod 100] := LSum;
end;

Measures: Integer arithmetic, array indexing, loop optimization, cache utilization
Data processed: 80 MB per iteration

3. Matrix Multiplication (matmul_64)

Standard matrix multiplication of two ×ばつ64 double-precision matrices:

for i := 0 to 63 do
 for j := 0 to 63 do
 for k := 0 to 63 do
 C[i,j] := C[i,j] + A[i,k] * B[k,j];

Measures: Floating-point arithmetic, nested loop optimization, memory access patterns
Data processed: 98,304 bytes per iteration

Methodology

Each benchmark:

1. Performs 2 warmup iterations
2. Auto-adjusts iteration count to achieve ~400ms total runtime
3. Reports average time per operation

Metrics:

• ns/op: Nanoseconds per operation (lower is better)
• ops/s: Operations per second (higher is better)
• MB/s: Data throughput in megabytes per second (higher is better)

Results

NitroPascal (releasefast)

Delphi (Release)

Performance Comparison

Analysis

String Concatenation

• Winner: Delphi (×ばつ faster)
• Delphi's native string implementation with copy-on-write semantics and optimized memory allocation significantly outperforms NitroPascal's C++ string runtime

Array Sum

• Winner: NitroPascal (×ばつ faster)
• NitroPascal benefits from modern C++ compiler optimizations including aggressive loop optimization and better instruction scheduling
• Throughput: NitroPascal 12,028 MB/s vs Delphi 7,387 MB/s

Matrix Multiplication

• Winner: NitroPascal (×ばつ faster)
• NitroPascal's C++ backend provides superior floating-point optimization and nested loop handling
• Throughput: NitroPascal 685.77 MB/s vs Delphi 435.16 MB/s

Summary

NitroPascal Performance Profile:

• Excels at numeric computation (×ばつ faster than Delphi)
• Strong performance on array operations and floating-point math
• Slower string handling (×ばつ slower than Delphi)

Delphi Performance Profile:

• Superior string manipulation performance
• Competitive numeric performance
• Mature, well-optimized runtime library

Reproducibility

Both compilers use identical source code to ensure fair comparison. Benchmarks can be reproduced using the NPBench suite included with NitroPascal.

Version: NPBench 1.0
Report Date: October 17, 2025