Performance Vergleich zwischen verschiedenen Programmiersprachen und Systemen?

Vor einiger Zeit habe ich von der sogenannten Leibniz-Reihe erfahren. Mit diesem Verfahren kann man Pi errechnen. Und wenn man schon dabei ist einen Benchmark durchführen 🙂

Ich habe den Programmcode in fünf Programmiersprachen umgesetzt (Fehler schließe ich hier nicht aus und ich freue mich über Hinweise) und zwar:

Python:

#!/usr/bin/python3
#Berechne Pi mit der Leibniz-Reihe
import time

iterations = 1000000

x = 1
pi = 1
start = time.time()
for i in range(2, iterations + 2):
   x = x * -1
   pi = pi + (x / (2*i-1))

pi = pi * 4
end = time.time()
print('Pi: ' + str(pi))
print('Time taken for ' + str(iterations) + ' Iterations: ' + str((end - start)*1000000) + ' Mikroseconds')

Javascript:

var iterations = 1000000;

var x = 1;
var pi = 1;
var begin=Date.now();
for (i = 2; i < iterations + 2; i++) {
  x = x * -1;
  pi = pi + (x / (2*i-1));    
}

pi = pi * 4;
var end= Date.now();
console.log('Pi: ' + pi);
console.log('Took ' + ((end-begin)*1000) + ' Microseconds');

PHP:

<?php
$iterations = 1000000;

$x = 1;
$pi = 1;

$begin = microtime(true);
for ($i = 2; $i < $iterations + 2; $i++) {
   $x = $x * -1;
   $pi = $pi + ($x / (2*$i-1));    
}

$pi = $pi * 4;
$end = microtime(true) - $begin;
echo('Pi: ' . $pi . "\n");
echo('Took ' . ($end * 1000 * 1000) . ' Microseconds' . "\n");
?>

C:

#include <stdio.h>
#include <sys/time.h>

int main()
{
   struct timeval start, end;
   long secs_used, micros_used;
   int iterations = 1000000;

   float x = 1;
   float pi = 1;
   gettimeofday(&start, NULL);
   for (int i = 2; i < iterations + 2; i++) {
      x = x * -1;
      pi = pi + (x / (2.0*i-1.0));    
   }

   pi = pi * 4;
   gettimeofday(&end, NULL);
   secs_used = (end.tv_sec - start.tv_sec);
   micros_used = ((secs_used*1000000) + end.tv_usec) - (start.tv_usec);
   printf("Pi: %f\n", pi);
   printf("micros_used: %ld\n", micros_used);
}

C#:

using System;
using System.Diagnostics;

namespace Leibniz
{
   class Program
   {
       static void Main(string[] args)
       {
           int iterations = 1000000;

           double x = 1;
           double pi = 1;
           Stopwatch stopwatch = Stopwatch.StartNew();
           for (int i = 2; i<iterations + 2; i++) {
               x = x* -1;
               pi = pi + (x / (2.0*i-1.0));    
           }

           pi = pi* 4;
           stopwatch.Stop();
           Console.WriteLine("Pi: " + pi);
           Console.WriteLine("micros_used: " + stopwatch.ElapsedMilliseconds * 1000);
       }
   }
}

Und C für Arduino:

void setup() {
   Serial.begin(9600);  
}

void loop() {
  unsigned long iterations = 1000000;

  Serial.println("Start");
  float x = 1;
  float pi = 1;
  unsigned long starttime = micros();
  for (unsigned long i = 2; i < iterations + 2; i++) {
     x = x * -1;
     pi = pi + (x / (2.0*i-1.0));    
  }

  pi = pi * 4;
  unsigned long endtime = micros();
 
  Serial.print("Pi: ");
  Serial.println(pi);
  Serial.print("Micros used: ");
  Serial.println(endtime - starttime);
}

Und hier gibt es ein paar Messergebnisse zu den obigen Programmcodes:

Das schöne hier dran ist dass man diesen Programmcode so ziemlich in jeder Sprache und auf jeder Hardware durchführen kann.

Selbstverständlich zeigt dieser Test nicht wie schnell die jeweilige Sprache/Hardware tatsächlich ist, sondern nur wie schnell sie mit Float-Berechnungen umgehen kann. Ein massiver Unterschied besteht natürlich wenn die jeweilige Hardware keine extra Floating Point Hardware besitzt (wie z.B. der Arduino Uno).