GDC vs dmd speed

[Paul Jurczak]

On Monday, 14 October 2013 at 19:24:27 UTC, Spacen Jasset wrote:
> Hello,
>
> Whilst porting some C++ code I have discovered that the 
> compiled output from the gdc compiler seems to be 47% quicker 
> than the dmd compiler.
....

Here is a few more data points for microbenchmarks of simple 
functions (Project Euler), which supports an observation 
(disclaimer: my microbenchmark is not a guarantee of your code 
performance, etc.) that the fastest code is produced by LDC, then 
GDC and DMD is the slowest one.

Tested on Xubuntu 13.04 64-bit Core i5 3450S 2.8GHz.

--------------------
Test 1:

// 454ns  LDC 0.11.0: ldmd2 -m64 -O -noboundscheck -inline 
-release
// 830ns  GDC 4.8.1: gdc -m64 -march=native -fno-bounds-check 
-frename-registers -frelease -O3
// 1115ns  DMD64 2.063.2: dmd -O -noboundscheck -inline -release


int e28_0(int N = 1002) {
	int diagNumber = 1;					
	int sum        = diagNumber;	

	for (int width = 2; width < N; width += 2)	
		for (int j = 0; j < 4; ++j) {			
			diagNumber += width;				
			sum        += diagNumber;			
		}

	return sum;
}

--------------------
Test 2:

// 118ms   LDC 0.11.0: ldmd2 -m64 -O -noboundscheck -inline 
-release
// 125ms   GDC 4.8.1: gdc -m64 -march=native -fno-bounds-check 
-frename-registers -frelease -O3
// 161ms   DMD64 2.063.2: dmd -O -noboundscheck -inline -release

bool isPalindrome(string s) {return equal(s, s.retro);}

int e4(int N = 1000) {
    int nMax = 0;

    foreach (uint i; 1..N)
       foreach (uint j; i..N)
          if (isPalindrome(to!string(i*j))  &&  i*j > nMax)
             nMax = i*j;

    return nMax;
}

--------------------
Test 3:

// 585us   LDC 0.11.0: ldmd2 -m64 -O -noboundscheck -inline 
-release
// 667us   GDC 4.8.1: gdc -m64 -march=native -fno-bounds-check 
-frename-registers -frelease -O3
// 853us   DMD64 2.063.2: dmd -O -noboundscheck -inline -release

int e67_0(string fileName = r"C:\Euler\data\e67.txt") {
    // Read triangle numbers from file.
    int[][] cell;

    foreach (line; splitLines(cast(char[]) read(fileName))) {
       int[] row;

       foreach (token; std.array.splitter(line))
          row ~= [to!int(token)];

       cell ~= row;
    }

    // Compute maximum value partial paths ending at each cell.
    foreach (y; 1..cell.length) {
       cell[y][0] += cell[y-1][0];

       foreach (x; 1..y)
          cell[y][x] += max(cell[y-1][x-1], cell[y-1][x]);

       cell[y][y] += cell[y-1][y-1];
    }

    // Return the maximum value terminal path.
    return cell[$-1].reduce!max;
}

--------------------
Here is the relative to LDC code speed averaged over these three 
test (larger number is slower):
LDC 1.00
GDC 1.34
DMD 1.76