Integer Performance Comparison for C++, C#, Delphi

In this post, I have compared three versions (from the same codebase) using Delphi to count the number of primes between 1 to N. Actually, this is quite a simple example that can be used to benchmark the integer computation for modern programming languages.

In order to make relative fair comparisons, the IsPrime function is implemented exactly the same despite the fact that it may be implemented using a different algorithm e.g. Fermat Prime Testing algorithm.

C# .NET Counting Primes

C# generates the CIL code, which is then JIT. So the performance of C# application is quite close to the native groups (C++, Delphi etc).

Serial Version

One of the advantages using C# is that we can use LINQ (or in functional programming style):

1
2
3

public static int Serial(int start, int end) =>
            Enumerable.Range(start, end - start)
                      .Count(IsPrime);

public static int Serial(int start, int end) =>
            Enumerable.Range(start, end - start)
                      .Count(IsPrime);

Parallel Version

Suprisingly, we just need to add .AsParallel() to the above C# code and that makes our parallel version:

public static int Parallel(int start, int end) =>
            Enumerable.Range(start, end - start)
                      .AsParallel()
                      .Count(IsPrime);

public static int Parallel(int start, int end) =>
            Enumerable.Range(start, end - start)
                      .AsParallel()
                      .Count(IsPrime);

It is the same as:

public static int Parallel(int start, int end) =>
            Enumerable.Range(start, end - start)
                      .AsParallel()
                      .Where(IsPrime)
                      .Count();

public static int Parallel(int start, int end) =>
            Enumerable.Range(start, end - start)
                      .AsParallel()
                      .Where(IsPrime)
                      .Count();

C# LINQ makes writting parallel code a lot easier. Assume that in the future, you want to ship your code to other platforms e.g. GPU cores, you don’t need to change a single line of code!

Delphi Counting Primes

We ‘ve listed the two versions in this post. However the parallel version is not optimial: it recursively splits the range into two halves which causes performance overhead. To make a fair comparison to the above C# (AsParallel) version, we rewrite the delphi code:

function Test2: integer;
var
  s: integer;
begin
  s := 0;
  TParallel.&For(1, MAXN, procedure(i: integer)
    begin
      if (IsPrime(i) = 1) then
      begin // memory barrier
        AtomicIncrement(s);
      end
    end);
  Result := s;
end;

Please note that, we use the AtomicIncrement to ensure the correct counting but this is the memory barrier. If we get rid of the conditional branch check, it will be slightly faster.

function Test3: integer;
var
  s: integer;
begin
  s := 0;
  TParallel.&For(1, MAXN, procedure(i: integer)
    begin // memory barrier
      AtomicIncrement(s, IsPrime(i));
    end);
  Result := s;
end;

The cost of increasing the chance of memory barrier is compensated by removing a branch check.

Visual Studio C++ Counting Primes

In Visual Studio C++, we can use the concurrency to implement the Parallel For:

int Parallel1(int n) {
    volatile long s = 0;
    Concurrency::parallel_for(0, n, [&](int i) {
        if (IsPrime(i)) {
            InterlockedIncrement(&s);
        }
    });
    return s;
}

int Parallel1(int n) {
	volatile long s = 0;
	Concurrency::parallel_for(0, n, [&](int i) {
		if (IsPrime(i)) {
			InterlockedIncrement(&s);
		}
	});
	return s;
}

Similarly, the following is slightly a bit faster:

int Parallel2(int n) {
    volatile long s = 0;
    Concurrency::parallel_for(0, n, [&](int i) {
        InterlockedAdd(&s, IsPrime(i));
    });
    return s;
}

int Parallel2(int n) {
	volatile long s = 0;
	Concurrency::parallel_for(0, n, [&](int i) {
		InterlockedAdd(&s, IsPrime(i));
	});
	return s;
}

MinGW OpenMP C++ Counting Primes

We use the MINGW C++ with OpenMP support:

int Parallel1(int n) {
    volatile long s = 0;
 
    #pragma omp parallel for
    for (int i = 1; i <= n; ++i) {
        if (IsPrime(i)) {
            InterlockedIncrement(&s);
        }
    }
    return s;
}
 
int Parallel2(int n) {
    volatile long s = 0;
 
    #pragma omp parallel for
    for (int i = 1; i <= n; ++i) {
        __sync_fetch_and_add(&s, IsPrime(i));
    }
    return s;
}

int Parallel1(int n) {
	volatile long s = 0;

	#pragma omp parallel for
	for (int i = 1; i <= n; ++i) {
		if (IsPrime(i)) {
			InterlockedIncrement(&s);
		}
	}
	return s;
}

int Parallel2(int n) {
	volatile long s = 0;

	#pragma omp parallel for
	for (int i = 1; i <= n; ++i) {
		__sync_fetch_and_add(&s, IsPrime(i));
	}
	return s;
}