Benchmark für Raspberry Pi

HaWe · 02.12.2014, 20:16

hallo,
mich würde jetzt wirklich mal interessieren, wie schnell der RPI bei benchmark-Tests abschneidet, und zwar
1x unter C
1x unter Python - und, wenn möglich,
1x unter Java.

Einen Benchmark Test für verschiedene MCUs habe ich schon - jetzt müsste man ihn nur für den RPi anpassen.

http://www.mindstormsforum.de/viewto...tart=60#p64772

Setup + design:
This benchmark test is including several test functions for different individual computational patterns:
- simple basic integer arithmetics (addition/substraction, multiplication/division),
- real and transcendental float arithmetic functions (sqrt,sin,cos, exp), preferably 64bit double (=> bonus points)
- advanced matrix algebra for more-dim array manipulation (matrix product + determinant, built-in or imported) (genuine multi-dim arrays => bonus points)
- pseudo random number generator (Mersenne Twister): low-level bit- and-byte-operations like AND, XOR, SHIFT-left/right
- quick high-level sort algorithm for arrays[500] (preferably Shellsort, built-in or imported),
- a text-output and a 2D-graphics test for graph + shape + fill computation and lcd output stressing.

the latest brickbench test enhancement also takes programming-environments into account, i.e.
- available memory, networking/chaining abilities,
- variable types (e.g. for double precision fp and matrices/more-dim arrays),
- recursions,
- multithreading support,
- and, last but not least, the wholeness of API functions for hardware (screen, and attached sensors and motors), and the IDE.

Wenn Python nämlich WIRKLICH geschwindigkeitsmäßig an C herankommt, wäre es ja wirklich eine Alternative.
Wer hat Lust und traut sich?

Der C-Code ist vorhanden und sicher leicht portierbar, mit Python und Java kenne ich mich (noch) nicht aus.
Den Grafik-Teil kann man notfalls (erstmal) weglassen und evtl später nachreichen.

Hier ist der C-Referenz-Code (danach auch einige Adaptationen, u.a. für Java, aber hier ist ein kleiner Fehler drin):

http://www.mindstormsforum.de/viewto...tart=60#p64494

Code:

// HaWe  brickbench
// benchmark test for NXT/EV3 and similar Micro Controllers
// PL: gpp CSLite C/C++, C-API and BCC by John Hansen
// Autor: (C) Helmut Wunder 2013,2014
// freie Verwendung für private Zwecke
// für kommerzielle Zwecke nur nach Genehmigung durch den Autor.
// protected under the friendly Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// http://creativecommons.org/licenses/by-nc-sa/3.0/
// version 1.08.2

#include <stdio.h>
#include <math.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/ioctl.h>

#include "lms2012.h"
#include "ev3_button.h"
#include "ev3_lcd.h"
#include "ev3_constants.h"
#include "ev3_command.h"
#include "ev3_timer.h"
#include "ev3_lcd.h"
#include "ev3_sound.h"
#include "ev3_output.h"


unsigned long runtime[8];

int a[500], b[500], c[500], t[500];


//--------------------------------------------
// Mersenne Twister
//--------------------------------------------

unsigned long randM(void) {
   const int M = 7;
   const unsigned long A[2] = { 0, 0x8ebfd028 };

   static unsigned long y[25];
   static int index = 25+1;

   if (index >= 25) {
     int k;
     if (index > 25) {
        unsigned long r = 9, s = 3402;
        for (k=0 ; k<25 ; ++k) {
          r = 509845221 * r + 3;
          s *= s + 1;
          y[k] = s + (r >> 10);
        }
     }
     for (k=0 ; k<25-M ; ++k)
        y[k] = y[k+M] ^ (y[k] >> 1) ^ A[y[k] & 1];
     for (; k<25 ; ++k)
        y[k] = y[k+(M-25)] ^ (y[k] >> 1) ^ A[y[k] & 1];
     index = 0;
   }

   unsigned long e = y[index++];
   e ^= (e << 7) & 0x2b5b2500;
   e ^= (e << 15) & 0xdb8b0000;
   e ^= (e >> 16);
   return e;
}

//--------------------------------------------
// Matrix Algebra
//--------------------------------------------

// matrix * matrix multiplication (matrix product)

void MatrixMatrixMult(int N, int M, int K, double A[][M], double B[][K], double C[][K]){
  int i, j, s;                                       // matrix A: N x M // B: M x K // C: N x K
  for (i=0; i<N; ++i) {
    for (j=0; j<K; ++j) {
       C[i][j]=0;
       for (s=0; s<M; ++s) {
         C[i][j]=C[i][j] + A[i][s]*B[s][j];
      }
    }
  }
}


// matrix determinant

double MatrixDet(int N, double A[N][N])
{
    int i,j,i_count,j_count, count=0;
    double Asub[N-1][N-1], det=0;

    if(N==1) return A[0][0];
    if(N==2) return (A[0][0]*A[1][1] - A[0][1]*A[1][0]);

    for(count=0; count<N; count++)
    {
        i_count=0;
        for(i=1; i<N; i++)
        {
            j_count=0;
            for(j=0; j<N; j++)
            {
                if(j == count) continue;
                Asub[i_count][j_count] = A[i][j];
                j_count++;
            }
            i_count++;
        }
        det += pow(-1, count) * A[0][count] * MatrixDet(N-1,Asub);
    }
    return det;
}


//--------------------------------------------
// shell sort
//--------------------------------------------

void shellsort(int size, int* A)
{
  int i, j, increment;
  int temp;
  increment = size / 2;

  while (increment > 0) {
    for (i = increment; i < size; i++) {
      j = i;
      temp = A[i];
      while ((j >= increment) && (A[j-increment] > temp)) {
        A[j] = A[j - increment];
        j = j - increment;
      }
      A[j] = temp;
    }

    if (increment == 2)
       increment = 1;
    else
       increment = (unsigned int) (increment / 2.2);
  }
}

//--------------------------------------------
// gnu quick sort
// (0ptional)
//--------------------------------------------

int compare_int (const int *a, const int *b)
{
  int  temp = *a - *b;

  if (temp > 0)          return  1;
  else if (temp < 0)     return -1;
  else                   return  0;
}

// gnu qsort:
// void qsort (void *a , size_a count, size_a size, compare_function)
// gnu qsort call for a[500] array of int:
// qsort (a , 500, sizeof(a), compare_int)



//--------------------------------------------
// benchmark test procedures
//--------------------------------------------


int test_Int_Add() {
   int i=1, j=11, k=112, l=1111, m=11111, n=-1, o=-11, p=-111, q=-1112, r=-11111;
   int x;
   volatile long s=0;
   for(x=0;x<10000;++x) {
     s+=i; s+=j; s+=k; s+=l; s+=m; s+=n; s+=o; s+=p; s+=q; s+=r;
   }
   return s;
}



long test_Int_Mult() {
  int x,y;
  volatile long s;

  for(y=0;y<2000;++y) {
    s=1;
    for(x=1;x<=13;++x) { s*=x;}
    for(x=13;x>0;--x) { s/=x;}

  }
  return s;
}


#define PI  M_PI


float test_float_math() {

  volatile float s=PI;
  int y;

  for(y=0;y<5000;++y) {
     s*=sqrt(s);
     s=sin(s);
     s*=cos(10.5*s);
     s=sqrt(s);
     s=exp(s);
  }
  return s;
}


long test_rand_MT(){
  volatile unsigned long s;
  int y;

  for(y=0;y<5000;++y) {
     s=randM()%10001;
  }
  return s;
}


float test_matrix_math() {
  int x;

  double A[2][2], B[2][2], C[2][2];
  double O[3][3], T[3][3];
  unsigned long s;

  for(x=0;x<250;++x) {

    A[0][0]=1;   A[0][1]=3;
    A[1][0]=2;   A[1][1]=4;

    B[0][0]=10;  B[0][1]=30;
    B[1][0]=20;  B[1][1]=40;

    MatrixMatrixMult(2,2,2, A,B,C);

    A[0][0]=1;   A[0][1]=3;
    A[1][0]=2;   A[1][1]=4;

    MatrixDet(2, A);

    O[0][0]=1;   O[0][1]=4;  O[0][2]=7;
    O[1][0]=2;   O[1][1]=5;  O[1][2]=8;
    O[2][0]=3;   O[2][1]=6;  O[2][2]=9;

    MatrixDet(3, O);

  }

  s=(O[0][0]*O[1][1]*O[2][2]);
  return s;
}



// for array copy using void *memcpy(void *dest, const void *src, size_t n);

long test_Sort(){
  unsigned long s;
  int y, i;
  int t[500];

  for(y=0;y<30;++y) {
    memcpy(t, a, sizeof(a));
    shellsort(500, t);
   
    memcpy(t, a, sizeof(b));
    shellsort(500, t);
   
    memcpy(t, a, sizeof(c));
    shellsort(500, t);
  }

  return y;
}



long test_TextOut(){

  int  y;
  char buf[120];

  for(y=0;y<20;++y) {
    LcdClearDisplay();
    sprintf (buf, "%3d %4d  int_Add",    0, 1000); LcdText(1, 0,10, buf);
    sprintf (buf, "%3d %4d  int_Mult",   1, 1010); LcdText(1, 0,20, buf);
    sprintf (buf, "%3d %4d  float_op",   2, 1020); LcdText(1, 0,30, buf);
    sprintf (buf, "%3d %4d  randomize",  3, 1030); LcdText(1, 0,40, buf);
    sprintf (buf, "%3d %4d  matrx_algb", 4, 1040); LcdText(1, 0,50, buf);
    sprintf (buf, "%3d %4d  arr_sort",   5, 1050); LcdText(1, 0,60, buf);
    sprintf (buf, "%3d %4d  displ_txt",  6, 1060); LcdText(1, 0,70, buf);
    sprintf (buf, "%3d %4d  testing...", 7, 1070); LcdText(1, 0,80, buf);

  }
  return 99;
}


long test_graphics(){
  int x=88, y;
  for(y=0;y<100;++y) {

    LcdClearDisplay();

    CircleOut(50, 40, 10);
    CircleOutEx(30, 24, 10, DRAW_OPT_FILL_SHAPE);
    LineOut(10, 10, 60, 60);
    LineOut(50, 20, 90, 70);
    RectOut(20, 20, 40, 40);
    RectOutEx(65, 25, 20, 30, DRAW_OPT_FILL_SHAPE);
    EllipseOut(70, 30, 15, 20);

  }
  return y;
}


inline void displayValues() {

  char buf[120];

    sprintf (buf, "%3d %4d  int_Add",    0, runtime[0]); LcdText(1, 0,10, buf);
    sprintf (buf, "%3d %4d  int_Mult",   1, runtime[1]); LcdText(1, 0,20, buf);
    sprintf (buf, "%3d %4d  float_op",   2, runtime[2]); LcdText(1, 0,30, buf);
    sprintf (buf, "%3d %4d  randomize",  3, runtime[3]); LcdText(1, 0,40, buf);
    sprintf (buf, "%3d %4d  matrx_algb", 4, runtime[4]); LcdText(1, 0,50, buf);
    sprintf (buf, "%3d %4d  arr_sort",   5, runtime[5]); LcdText(1, 0,60, buf);
    sprintf (buf, "%3d %4d  displ_txt",  6, runtime[6]); LcdText(1, 0,70, buf);
    sprintf (buf, "%3d %4d  graphics",   7, runtime[7]); LcdText(1, 0,80, buf);
}


void Handler(int sig)     //  fix ?
{
  //printf("handler %d\n", sig);   
}

int main(){

  unsigned long time0, x, y;
  float s;
  char  buf[120];
  int   i;

  SetTimerCallback(ti1sec, &Handler);

  ClearTimer(0);
  ClearTimerMS(0);

  ButtonLedInit();
  LcdInit();
  LcdClean();


  LcdText(1, 0,10, "hw brickbench");
  LcdText(1, 0,20, "(C)H.Wunder 2013");
  LcdText(1, 0,50, "initializing...");

  for(y=0;y<500;++y) {
    a[y]=randM()%30000; b[y]=randM()%30000; c[y]=randM()%30000;
  }


  LcdClearDisplay();

  time0= TimerMS(0);;
  s=test_Int_Add();
  runtime[0]=TimerMS(0)-time0;
  sprintf (buf, "%3d %4d  int_Add",    0, runtime[0]); LcdText(1, 0,10, buf);

  time0=TimerMS(0);
  s=test_Int_Mult();
  runtime[1]=TimerMS(0)-time0;
  sprintf (buf, "%3d %4d  int_Mult",   0, runtime[1]); LcdText(1, 0,20, buf);

  time0=TimerMS(0);
  s=test_float_math();
  runtime[2]=TimerMS(0)-time0;
  sprintf (buf, "%3d %4d  float_op",   0, runtime[2]); LcdText(1, 0,30, buf);

  time0=TimerMS(0);
  s=test_rand_MT();
  runtime[3]=TimerMS(0)-time0;
  sprintf (buf, "%3d %4d  randomize",  0, runtime[3]); LcdText(1, 0,40, buf);

  time0=TimerMS(0);
  s=test_matrix_math();
  runtime[4]=TimerMS(0)-time0;
  sprintf (buf, "%3d %4d  matrx_algb", 0, runtime[4]); LcdText(1, 0,50, buf);


  time0=TimerMS(0);
  s=test_Sort();
  runtime[5]=TimerMS(0)-time0;
  sprintf (buf, "%3d %4d  arr_sort",   0, runtime[5]); LcdText(1, 0,60, buf);

  time0=TimerMS(0);
  s=test_TextOut();
  runtime[6]=TimerMS(0)-time0;
  LcdClearDisplay();
  displayValues();

  time0=TimerMS(0);
  s=test_graphics();
  runtime[7]=TimerMS(0)-time0;
  LcdClearDisplay();
  displayValues();


  LcdText(1, 0,100, "cont: press btn < LEFT...");

  while(ButtonWaitForAnyPress(100) != BUTTON_ID_LEFT);

  LcdClearDisplay();
  y=0;
  for(x=0;x<8;++x) {y+= runtime[x];}

  sprintf (buf, "gesamt ms: %d ", y);           LcdText(1, 0,10, buf);
  sprintf (buf, "benchmark: %d ", 50000000/y ); LcdText(1, 0,20, buf);

  LcdText(1, 0,40, "quit: press btn < LEFT...");   // to be fixed  ! <<<<<<<<< no reaction, just for left + ESC !

  while(ButtonWaitForAnyPress(100) != BUTTON_ID_LEFT);

  LcdExit();
  ButtonLedExit();
  return 1;

}

shedepe · 03.12.2014, 00:21

Das was du suchst wurde bereits im Raspberry Pi Forum gemacht:
http://www.raspberrypi.org/forums/vi...p?f=81&t=25418

Wie wäre es ansonsten, dass du einen funktionierenden C Referenz Code implementierst den man dir dann nach Java oder Python porten kann ?

HaWe · 03.12.2014, 08:37

nein danke, ich will ja den RPi auch mit den ganzen anderen Plattformen vergleichen können, für die bereits Messergebnisse existieren (s. Tabelle).
Er wird inzwischen auch von EV3-Software- und VM- Entwicklern (RobotC, Mono/C#, leJOS/Java) benutzt als Vergleich und zur Performanceoptimierung.
Ich selber besitze aber auch noch gar keinen RPi, es soll ja zur Kaufentscheidung dienen.

(ps: und mein Benchmark testet ja auch viel differenzierter in viel mehr Einzeltests in einer viel größeren Bandbreite an Rechenoperationen und Funktionen als nur dieses Primzahlending in deinem Link; andererseits ist mein Referenzcode ja bereits gpp C/C++, wie man es auch mit Eclipse auf Linux-Plattformen benutzt. )

shedepe · 03.12.2014, 09:48

Was willst du überhaupt alles Benchmarken ? Nur Arm CPUs oder auch 8bit Prozessoren ? Worauf kommt es dir bei der Kaufentscheidung an ?
Aus der Erfahrung kann ich auch sagen, dass man nur selten wirklich jedes quäntchen Performance rauskitzelt (Einfach weil es abartig Zeitaufwändig ist) oder gar die Programmiersprache nach der Performance wählt. Meistens ist es sinnvoller man wählt die Programmiersprache nach den benötigten Libraries aus und danach was man besser programmieren kann.

Desweiteren versuchst du (soweit ich das erkennen kann) gerade auch Plattformen auf denen ein komplettes Betriebssystem läuft mit Plattformen zu vergleichen die kein oder nur ein sehr rudimentäres Betriebssystem haben. Worauf ich letztendlich hinauswill. Selbst mal wenn du den Benchmark portest, die Frage ist ob du ein aussagekräftiges Ergebnis bekommen wirst und ob du wirklich etwas damit anfangen kannst.

HaWe · 03.12.2014, 10:06

ich nutze es halt zur Kaufentscheidung. Es sind typische Operationen wie ich und andere sie öfters nutzen zu unterschiedlichsten Zwecken.
Insbesondere geht es um den Unterschied C vs. Python vs. Java, und auch vs. EV3 und vs. Arduino Due.
Auch der EV3 ist 32-bit ARM- und Linux-basiert (TI oder Debian).
Es muss ja nicht DICH interessieren, aber MICH interessiert es.

shedepe · 03.12.2014, 11:52

So hätte ich das jetzt nicht formuliert. Schließlich will man ja vor dem Kauf durchaus wissen, was man sich kauft. Die Frage ist aber echt wie aussagekräftig ein Benchmark ist. Für vergleichbare Ergebnisse würde ich stark eher zu Standard benchmark Tools wie sysbench oder stress raten ( Nachteil -> verschiedene Programmiersprachen werden nicht verglichen -> darauf gehe ich aber noch ein)
Ich könnte dir aber den Benchmark in C auf nem Raspberry ausführen wenn du darauf bestehst und wenn du ihn selber anpasst und durch einen crosscompiler schiebst. (Anpassen ist echt einfach. Alle Hardware spezifischen Sachen entfernen bzw. die Timer durch ctime ersetzen)
Für den Unterschied C - Java - Python - die werden kaum anderes sein als für andere Plattformen wobei man dran denken sollte, dass Java durch wenig Ram auch ausgebremst werden kann. Aber um für Geschwindigkeitsunterschiede zwischen einzelnen Programmiersprachen akzeptable Benchmarks zuerstellen braucht es mehr Zeit als die meisten Leute in einem Forum investieren wollen, über solche Themen wurden schon ganze wissenschaftliche Arbeiten verfasst ( http://www.azulsystems.com/blog/clif...rformanceagain ). Die Python Entwickler äußern sich sogar direkt zur Performance : https://wiki.python.org/moin/PythonSpeed -> Man kann z.B. C -Module in Python verwenden die eben stark optimiert wurden. Reine CPU Intensive Operationen wie dein Benchmark sie ausführt werden aber kaum feststellbare Unterschiede ergeben.
Deine Testfunktionen testen vorallem die CPU Leistung und allerhöchstens noch die Zugriffgeschwindigkeit auf den L1 Cache. Zudem muss man auch noch beachten, dass einige Raspian Distros anscheinend Probleme mit der Detection des L1 Caches haben. Interessant für eine allgemeine Leistungsaussage sind jedoch noch viel mehr Daten: Speicherzugriffsraten, Zugriffszeiten, Transferzeiten zur GPU. Hier kommt es auch stark auf die später geplante Anwendung an wie diese gewisse Zugriffe macht, in wiefern sie optimiert wurde, ob sie von der Hardwarebeschleunigung profitieren kann oder nicht. Dies ist eben gerade interessant wenn man Java und Python verwendet. Hier kann man z.B. bei vielen IO Zugriffen in eine Performancefalle laufen -> kann man aber bei python durch bestimmte Optimierungen gut umgehen.

**Peter(TOO)** · 03.12.2014, 13:58

Hallo,

Man muss auch sehr aufpassen, WAS man da misst!

Bei einer CPU ohne Fliesskomma-Einheit, testet ein Fliesskommatest nur das Emulationspaket des Compilers. Emulierte Fliesskomma-Operationen sind in der Grössenordnung 100x langsamer als eine Hardware-Einheit. Die Frage ist dann auch noch, welches Fliesskomma-Format verwendet wird!

Und nicht vergessen, die Steigerung von Lüge:
Lüge - Meineid- Statistik - Benchmark

Ein IAR-Konkurrent hatte auch mal seinen Compiler für die H8 von Hitachi mit Benchmarks beworben und wesentlich besser abgeschnitten.
Der Trick war: Nach einem Reset läuft der H8 mit 3 Wait-States, damit er auch mit langsamem Speicher startet. Beim IAR-Paket muss man die Wait-States dann selber hoch setzen, beim Konkurrenten hat das der Compiler automatisch eingefügt (Dann muss man aber mit langsamem Speicher das von Hand ändern, sonst läuft es nicht).
Tja.... Ist auch schon 20 Jahre her ...

MfG Peter(TOO)

HaWe · 03.12.2014, 14:15

ich will jetzt nicht über denn Sinn aller Einzeltests diskutieren oder das Gesamtresultat -
der Benchmark misst, was der Benchmark misst.

Zufällig misst er genau das, was mich (und andere) interessiert, und er ist auf mehreren Plattformen etabliert.
Also wird er (zunächst, mittelfristig) so bleiben, und wenn er mal verbessert wird (was ja sein kann), so müssen ntl auch alle Codes für alle anderen Plattformen neu programmiert werden.
Das ist nicht einfach, weil viele Codes von anderen Nutzern stammen, die ich selber gar nicht ändern kann und wo ich auch gar nicht die Plattformen dazu habe und nutze (u.a. C#, Java, RobotC, Toppers C).

Wäre also schön, wenn man als Zusatzplattform für den bestehenden Test auch den RPi hätte mit 2-3 verschiedenen Programmiersprachen.
V.a. C und Python halt, ggf auch Java.

ps,
wenn man sich an die C-Vorlage hält, insb. was die "volatiles" angeht, wird hier schon was vergleichbares herauskommen.
Außerdem kann ja jeder dann den entspr. angepassten Code selber testen und auf Fehler oder Cheats überprüfen (wer will und mag).

pps,
C-Module in Python gehen ntl normalerweise nicht, es sollen ja die "nackten" Codes verglichen werden. Es dürfen in einigen Fällen (z.B. sort) auch library-Implementationen verwendet werden.
Genau das soll ja der Test widerspiegeln:
sowohl einfache elementare und dann zunehmend kompliziertere bis hin zu hochkomplexen Berechnungen und Display-Output Operationen.
Jeder kann sich da übrigens für sich selber herausfiltern, was ihm persönlich am wichtigsten ist.

Für mich persönlich ist das:
einfach alles.

**peterfido** · 03.12.2014, 16:22

Vergiss die Benchmarkgeschichte. Die sagt nichts aus. Bei dem nächsten Update oder auch nur einer anderen kleinen Lib kann es schon ganz anders aussehen. Vom Multitasking, welches mehr oder weniger bremsen kann, ganz zu schweigen.

Sag einfach (oder besser umfangreich), was Du mit dem Raspi vorhast und evtl. hat es schon jemand so oder ähnlich gemacht und kann Dir seine Erfahrungen mitteilen.

Edit:
Oder kauf Dir einfach einen. Für ~30 Euro kann man da nichts falsch machen, wenn man Bastel- Programmierfreund ist sowieso nicht..