Benchmark für Raspberry Pi

[Valen]

Das hier schon gesehen?


http://www.roylongbottom.org.uk/Rasp...Benchmarks.htm


Es ist aber nicht ein verlgleich von MCUs, sondern Klein-computer Prozessoren.

[HaWe]

nicht speziell diese Übersicht, aber ähnliche, weniger umfangreiche.
Alle testen aber weder EV3s noch NXTs noch Arduino Megas noch Arduino Dues.
Mit geht es um den direkten Vergleich mit ein und demselben Benchmark für diese vorgenannten Hardware- und Software-Plattformen und auch für RPi (und später auch BBB).
Welcher jetzt besser sein könnte, steht gar nicht zur Debatte - jeder hat seine spezielle Berechtigung.

Aber gerade wegen der Lego-MCUs nehme ich meinen Benchmark als Vergleichsbasis, die auch die detaillierten Stärken und Schwächen einiger spezieller Plattformen besonders unter die Lupe nimmt (z.B. bit/byte-shift, mehrdim. Arrays rekursiv und array sort., daneben Display und "Programmier-Environment")

- - - Aktualisiert - - -

also... -
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

// 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;

}

(edit: wem die Arduino-Portierung besser als Basis gefällt, kann stattdessen auch diese verwenden: http://www.mindstormsforum.de/viewto...tart=60#p64772 - sie enthält allerdings nicht den Display -Test-Teil, da ich selber noch kein Arduino-TFT mit entspr. Libs besitze). Diese Portierung stammt von mir selber und ist ansonsten 100% vergleichbar.

Weitere Portierungen, z.B. für C# und Java, finden sich oberhalb oder unterhalb dieses Links - diese stammen allerdings nicht von mir selber und können durchaus Fehler enthalten. Für Java wurde das berichtet, aber noch nicht korrigiert. Hier würde Java nach Berichtigung sogar etwas besser abschneiden.

[Manf]

Ich sehe auch mit Bedauern, dass man hier nicht richtig weiterkommt, immerhin sind sehr erfahrene Forenmitglieder an der Diskussion beteiligt.
Die Härte der Diskussion ist etwas über dem sinnvollen Level, es ufert nicht wirklich aus, aber es geht eben auch nicht weiter.

Fast hätte ich schon vorgeschlagen einen besonders einfachen wenn auch nicht zu aussagekräftigen Benchmark zu versuchen, aber da ist mir peterfido zuvor gekommen, der das ganze dann schon wieder sehr ironisch aufbereitet hat.

Manf (als Moderator)



Lassen wir das mal so stehen, mit der Option dass der TO auch einen neuen Thread aufmachen kann.
Wenn dort nichts kommt dann eben nicht.
Das Recht auf einen sachlichen Umgang mit dem jeweiligen Thema soll man ja haben, (auch wenn es nicht lösbar sein sollte).

[HaWe]

@manf: vielen Dank

übrigens wofür der RPi mit Python gedacht war:
spezielle Rechentests weil ich solche Art von Berechnungen ständig für viel Arithmetik und Algebra benutze (Anwendungsprogramme: inverse Kinematik, Navigation, FFT, Kalman-Filter, Monte-Carlo-Filter, Astar, Neuronale Netze), als schnelleren und leistungsfähigeren Ersatz für meine NXTs und Arduino Dues, auf denen diese Anwendungsprogramme nur teilw. oder gar nicht laufen wegen viel zu geringer Geschwindigkeit und viel zuwenig RAM und/oder Flash.

[Technipion]

Hallo Leute,
ich finde es auch nicht gut wenn respektlos miteinander umgegangen wird, das möchte ich nur beiden Seiten gesagt haben. Mich stört es nicht einmal, dass die "bösen" Beiträge wieder entfernt wurden
Aber nun zurück zu HaWes Frage:
Das hier ist genau der Satz, auf den wir alle gewartet hatten:

übrigens wofür der RPi mit Python gedacht war:
spezielle Rechentests weil ich solche Art von Berechnungen ständig für viel Arithmetik und Algebra benutze (Anwendungsprogramme: inverse Kinematik, Navigation, FFT, Kalman-Filter, Monte-Carlo-Filter, Astar, Neuronale Netze), als schnelleren und leistungsfähigeren Ersatz

Jetzt können wir dir präzise Antworten, ganz ohne Benchmark
In der Regel (das trifft auch auf den RPI zu) ist Python etwa um einen Faktor 1,5 bis 10 langsamer als C. Das kommt einfach daher wie der Python-Interpreter funktioniert. Bei reinen Anwendungsprogrammen ist das allerdings kein Problem, die Performance ist hier meist zweitrangig (so stört es z.B. niemanden, dass die Youtube-Server fast komplett mit Python gescriptet sind). Google setzt übrigens Python ein, weil es durchaus seine Stärken hat (@HaWe: Falls du Python lernst, und dir hierfür ein gutes Buch zulegst, werden die Vorteile von Python sicherlich deutlich).
Eine dieser Stärken ist die hohe Modularität, und genau hier kommen wir zum Thema:
Schreibst du rechenintensive Anwendungen, bei denen es um Performance geht, dann skriptest du diese nicht in Python, sondern lässt die Rechnungen von einem Modul (C-like: Bibliothek) ausführen. Bei dir wäre wohl numpy/scipy (http://www.scipy.org/) angebracht. Diese Module sind selbst in C/C++ geschrieben, Python ruft lediglich die bereits compilierten Funktionen auf. Dadurch erreichst du - zumindest bei den Berechnungen - C-Geschwindigkeit. Normalerweise ist Python mit externem C-Modul bereits schnell genug für Game-Engines (siehe http://www.panda3d.org/). Die richtigen Hardcore-Bastler könnten die Performance mit PyPy (http://pypy.org/) bzw. RPython allerdings noch weiter steigern. Bei stackoverflow hatten sie da mal einen schönen Vergleich gezogen (http://stackoverflow.com/questions/6...ang-vs-haskell).
Dein Benchmark hätte dir auf dem RPI mit Sicherheit die gleichen relativen Laufzeiten ausgegeben.
Falls du dich entscheiden solltest dein Programm in Python zu Schreiben, und es dann nicht schnell genug laufen sollte, dann kannst du dich immernoch an ein Programmierforum wenden und den Code optimieren. Grundsätzlich kann man jedes Programm in jeder Sprache realisieren...

Grüße Technipion

[HaWe]

dankeschön für die Klarstellung, aber ich möchte nicht vorwiegend auf externe libs zurückgreifen müssen, das ist mir zu umständlich und damit kenne ich mich erst recht nicht aus. Außerdem muss man da sicher wieder auf Linux-Shell-Ebene rummanipulieren oder sich sogar selber mit C-Compilern, Eclipse unf Makefile rumquälen:
Bei einfachen Array-Sortieralgorithmen wie qsort geht das ja gerade noch, wen man sie schon auf dem Flash oder der SD drauf hat und sie nur noch includen muss, aber alles andere müsste "nativ" funktionieren...

Schließlich schreibe ich ja meine eigenen Routinen je nach Bedarf mal so, mal so, und ich muss im Quellcode die Möglichkeit haben, einfach mal eben die einen oder anderen Berechnungen runterschreiben zu können.

Daher wäre zur Beurteilung der einzelnen RPi-Fähigkeiten und Schwachstellen eben doch der Benchmark (C / Python / Java) interessant gewesen, ganz unabhängig von späteren konkreten Projekten.