Projekt HaWe brickbench Benchmark Test f. NXT, EV3 & andere CPUs

Allgemeines und oft gestellte Fragen (z.B. Baukästen, Anleitungen, Projekte...)

Moderator: Moderatoren

Martin0x5E
Schreibt super viel
Schreibt super viel
Beiträge: 496
Registriert: 17. Dez 2011 11:39
Wohnort: Österreich

Re: hw brickbench: Benchmark Test für NXT und EV3

Beitragvon Martin0x5E » 14. Dez 2013 11:47

Bringt es keine RT Vorteile wenn man in nxc die Arrays per Referenz übergibt?
Stell ich mir ziemlich aufwendig vor so große Arrays per Value zu übergeben.

Code: Alles auswählen

void MatrixMatrixMult(float &A[][], float &B[][], float &C[][], int N, int M, int K)

void MatrixMatrixMult(float &A[][], float &B[][], float &C[][], int N, int M, int K)
Projekte und Informationen auf meiner Website: http://roboticsaumair.jimdo.com/

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 11:51

ich vermute, deine Frage bezieht sich auf NXC...?

bei NXC geht das nicht anders bzw. logisch korrekt, denn NXC hat keine Pointer: "by reference" ist ein fake !! 8-)
reference und value werden identisch interpretiert und als Kopie übergeben, nur einmal wird die veränderte Kopie zurückgegeben (by pseudo-reference) und mal nicht ( by value).
Daher identische (lahme) Geschwindigkeit. ;)

es gibt übrigens auch keine echten lokalen Variablen bei NXC: alle liegen global auf dem "clump", nur verschieden markiert: daher auch irre Speicherverschwendung bei vielen lokalen Variablen im jew. Programm!

Martin0x5E
Schreibt super viel
Schreibt super viel
Beiträge: 496
Registriert: 17. Dez 2011 11:39
Wohnort: Österreich

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon Martin0x5E » 14. Dez 2013 14:00

Da ich schon länger nicht mehr mit NXC programmiere habe ich jetzt mal probiert wie sich nxtOSEK im Vergleich schlägt.
Ich wollte jetzt nicht das ganze Programm portieren; habe also nur die ersten 3 Benchmarks gemacht.

Code: Alles auswählen

/* sample.cpp for TOPPERS/ATK(OSEK) */

/**
 * nxtOsek C++ NXtpandedLib
 * Author: Martin Aumair
 * License: GNU GPL on all Files
 * No release (yet)
 */


extern "C" {

#include "C:/cygwin/nxtOSEK/toppers_osek/include/kernel.h"
#include "kernel_id.h"
#include "C:/cygwin/nxtOSEK/ecrobot/c/ecrobot_interface.h"


DeclareResource(ostreamRes);
DeclareTask(TaskMain);
DeclareEvent(EventSleep);
DeclareEvent(EventSleepI2C);
DeclareCounter(SysTimerCnt);

} // extern C

#include <cmath>;
#include "NTimer.hpp"
#include "ostream.hpp"

mutex_t streammtx(ostreamRes);
ostream cout(streammtx);
#include "NLabel.hpp"

extern "C" {

// nxtOSEK hook to be invoked from an ISR in category 2
void user_1ms_isr_type2(void){
   SleeperMonitor();
   StatusType ercd;

   ercd = SignalCounter(SysTimerCnt); /* Increment OSEK Alarm Counter */
   if (ercd != E_OK) {
       ShutdownOS(ercd);
   }
}

// hooks
void ecrobot_device_initialize(void);
void ecrobot_device_terminate(void);


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<2000;++x) {
     s+=i; s+=j; s+=k; s+=l; s+=m; s+=n; s+=o; s+=p; s+=q; s+=r;
   }
   return (int)s;
}

long test_Int_Mult() {
  volatile long s;
  int i, x, y;
  for(y=0;y<200;++y) {
    i=1;
    s=1;
    for(x=0;x<13;++x) { s=s*i++;}
    i--;
    for(x=0;x<13;++x) { s=s/i--;}
  }
  return s;
}

float test_float_math() {
  float s=M_PI;
  int y;

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


TASK(TaskMain) {
   float s = 0.0;
   cout << "benchmark test" << endl;

   NTimer timer;
   timer.start();
   s = test_Int_Add();
   timer.stop();

   cout << "int_Add: " << timer.getLast() << endl;

   timer.reset();
   timer.start();
   s = test_Int_Mult();
   timer.stop();

   cout << "int_Mult: " << timer.getLast() << endl;

   timer.reset();
   timer.start();
   s = test_float_math();
   timer.stop();

   cout << "float_math: " << timer.getLast() << endl;

   TerminateTask();
}


} // extern "C"


Output:

Code: Alles auswählen

benchmark test
int_Add: 5
int_Mult: 16
float_math: 87



Das bestätigt für mich mal wieder die Wahl für nxtOSEK.
Im Vergleich zum EV3 nur 4x langsamer als der 300 MHz neuere Prozessor vom EV3 ist für mich sogar etwas überraschend!
Projekte und Informationen auf meiner Website: http://roboticsaumair.jimdo.com/

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 15:05

der NXT hat 48 MHz, der EV3 300 MHz,
300/48 ≈ 6
d.h. vom Prozessortakt ist der NXT 6 x langsamer, was doch etwa deinen relativen Werten entspricht, oder ?
(naja, gut, eigtl 5x...Allerdings läuft beim EV3 z.Zt immer noch die Lego-VM zeitgleich parallel, was den EV3 ntl momentan noch zusätzlich verlangsamt

benchmark test nxtOSEK...EV3
int_Add:..........5........1
int_Mult:........16........1
float_math:..... 87.......21

sum:............108.......23



Trotzdem würde es mich sehr interessieren, mal den gesamten benchmark portiert zu sehen -
an sich müsste man doch den C- code 1:1 übernehmen können, bis auf die LCD-Ausgabe...?
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 15:51

Code: Alles auswählen

/* sample.cpp for TOPPERS/ATK(OSEK) */

/**
 * nxtOsek C++ NXtpandedLib
 * Author: Martin Aumair
 * License: GNU GPL on all Files
 * No release (yet)
 */


extern "C" {

#include "C:/cygwin/nxtOSEK/toppers_osek/include/kernel.h"
#include "kernel_id.h"
#include "C:/cygwin/nxtOSEK/ecrobot/c/ecrobot_interface.h"


DeclareResource(ostreamRes);
DeclareTask(TaskMain);
DeclareEvent(EventSleep);
DeclareEvent(EventSleepI2C);
DeclareCounter(SysTimerCnt);

} // extern C

#include <cmath>;
#include "NTimer.hpp"
#include "ostream.hpp"

mutex_t streammtx(ostreamRes);
ostream cout(streammtx);
#include "NLabel.hpp"

extern "C" {

// nxtOSEK hook to be invoked from an ISR in category 2
void user_1ms_isr_type2(void){
   SleeperMonitor();
   StatusType ercd;

   ercd = SignalCounter(SysTimerCnt); /* Increment OSEK Alarm Counter */
   if (ercd != E_OK) {
       ShutdownOS(ercd);
   }
}

// hooks
void ecrobot_device_initialize(void);
void ecrobot_device_terminate(void);


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<2000;++x) {
     s+=i; s+=j; s+=k; s+=l; s+=m; s+=n; s+=o; s+=p; s+=q; s+=r;
   }
   return (int)s;
}

long test_Int_Mult() {
  volatile long s;
  int i, x, y;
  for(y=0;y<200;++y) {
    i=1;
    s=1;
    for(x=0;x<13;++x) { s=s*i++;}
    i--;
    for(x=0;x<13;++x) { s=s/i--;}
  }
  return s;
}

float test_float_math() {
  float s=M_PI;
  int y;

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


TASK(TaskMain) {
   float s = 0.0;
   cout << "benchmark test" << endl;

   NTimer timer;
   timer.start();
   s = test_Int_Add();
   timer.stop();

   cout << "int_Add: " << timer.getLast() << endl;

   timer.reset();
   timer.start();
   s = test_Int_Mult();
   timer.stop();

   cout << "int_Mult: " << timer.getLast() << endl;

   timer.reset();
   timer.start();
   s = test_float_math();
   timer.stop();

   cout << "float_math: " << timer.getLast() << endl;

   TerminateTask();
}


} // extern "C"
Trotzdem würde es mich sehr interessieren, mal den gesamten benchmark portiert zu sehen -
an sich müsste man doch den C- code 1:1 übernehmen können, bis auf die LCD-Ausgabe...?


habe jetzt in meinem Code alle testloops um den Faktor 5 erhöht, um eine feinere Auflösung zu bekommen.

Könntest du vllt dann auch deinen Test nochmal neu fahren, evtl. mit weiteren zusätzlichen?


Alle weiteren und neueren Ergebnisse sammle ich jetzt hier:

https://sourceforge.net/apps/phpbb/mindboards/viewtopic.php?f=3&t=2035&start=0
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Martin0x5E
Schreibt super viel
Schreibt super viel
Beiträge: 496
Registriert: 17. Dez 2011 11:39
Wohnort: Österreich

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon Martin0x5E » 14. Dez 2013 16:02

Ok ich werde mich jetzt daran machen alles zu portieren.
Die Compiler-Flag stell ich jetzt auch auf maximale Geschwindigkeitsoptimierung, mal schaun ob es was hilft :P

Habe gerade gesehen das wir nicht das selbe PI nutzen^^
Kannst du vielleicht auch die Standard-Konstante M_PI nutzen?
Projekte und Informationen auf meiner Website: http://roboticsaumair.jimdo.com/

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 17:20

ok, ist drin!

Code: Alles auswählen

#define PI  M_PI


Nachtrag -
wichtig:
bitte setze alle Variablen auf "volatile", wo ich es auch gemacht habe, sonst optimiert der Compiler manche Zeilen raus und rechnet nicht mehr!

und noch was fiel mehr gerad auf:
bitte nimm mal die arrays d[500] und e[500] raus, denn ich habe den Eindruck, der NXT gerät da in Speicher-Probleme!
ich mach es jetzt neu nur mit arrays a,b,c (und t) !
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Martin0x5E
Schreibt super viel
Schreibt super viel
Beiträge: 496
Registriert: 17. Dez 2011 11:39
Wohnort: Österreich

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon Martin0x5E » 14. Dez 2013 19:11

So Zwischenstand:

3 Variablen werden mir vom Compiler als "unused" markiert.

Code: Alles auswählen

int iter, jter, inc, temp, i, j; // iter, jter unused!

float O[3][3], T[3][3];  // T unused!


Für den Grafik-Benchmark muss ich mir noch was überlegen da ich das Zeichnen von Ellipsen noch nicht implementiert habe.

Hier der aktuelle Code:

Code: Alles auswählen

/* sample.cpp for TOPPERS/ATK(OSEK) */

/**
 * nxtOsek TOPPERS/ATK C/C++
 * Credits to HaWe-bench by Helmut Wunder
 * Porting to nxtOSEK: Martin Aumair
 * Author: http://roboticsaumair.jimdo.com/
 * License: GNU GPL on all Files
 *
 * See also:
 * http://sourceforge.net/apps/phpbb/mindboards/viewtopic.php?f=3&t=2035&start=0
 * http://www.mindstormsforum.de/viewtopic.php?p=63607#p63607
 */


extern "C" {

#include "C:/cygwin/nxtOSEK/toppers_osek/include/kernel.h"
#include "kernel_id.h"
#include "C:/cygwin/nxtOSEK/ecrobot/c/ecrobot_interface.h"


DeclareResource(ostreamRes);
DeclareTask(TaskMain);
DeclareEvent(EventSleep);
DeclareEvent(EventSleepI2C);
DeclareCounter(SysTimerCnt);

} // extern C

#include <cmath>;
#include <cstdio>;

/*
mutex_t streammtx(ostreamRes);
ostream cout(streammtx);
#include "NLabel.hpp"
*/

/////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////OSEK HOOKS/IRS///////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////

extern "C" {

// nxtOSEK hook to be invoked from an ISR in category 2
void user_1ms_isr_type2(void){
   //SleeperMonitor();
   StatusType ercd;

   ercd = SignalCounter(SysTimerCnt); /* Increment OSEK Alarm Counter */
   if (ercd != E_OK) {
       ShutdownOS(ercd);
   }
}

// hooks
void ecrobot_device_initialize(void);
void ecrobot_device_terminate(void);



/////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////BENCHMARK FUNCTIONS////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////


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



void MatrixMatrixMult(int N, int M, int K, float A[][2], float B[][2], float C[][2]) {
   int i, j, s;
   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 is in nxtOsek same as float
// no VLA!

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

   if (N == 1)
      return *A;
   if (N == 2)
      return ((*A) * (*(A+1+1*N)) - (*(A+1*N)) * (*(A+1)));

   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*N);
            j_count++;
         }
         i_count++;
      }
      det += pow(-1, count) * A[0+count*N] * MatrixDet(N - 1, &Asub[0][0]);
   }
   return det;
}


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

void shellsort(int size, int *array) {
   int iter, jter, inc, temp, i, j;
   for (inc = size / 2; inc > 0; inc /= 2) {
      for (i = inc; i < size; i++) {
         temp = array[i];
         for (j = i; j >= inc; j -= inc) {
            if (temp < array[j - inc]) {
               array[j] = array[j - inc];
            } else {
               break;
            }
         }
         array[j] = temp;
      }
   }
}


//--------------------------------------------
// 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() {

  volatile long s;
  int i, x, y;
  for(y=0;y<1000;++y) {
    i=1;
    s=1;
    for(x=0;x<13;++x) { s=s*i++;}
    i--;
    for(x=0;x<13;++x) { s=s/i--;}

  }
  return s;
}





float test_float_math() {

   float s = M_PI;
   int y;

   for (y = 0; y < 10000; ++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;

   float A[2][2], B[2][2], C[2][2];
   float 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[0][0]);

      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[0][0]);

   }

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



long test_Sort(){
  int y;

  for(y=0;y<250;++y) {
    shellsort(500, a);
    shellsort(500, b);
    shellsort(500, c);
  }

  return y;
}


// helper functions for output
// normally with cout our sprintf but I think in a benchmark we take the fastest method
void NumOut(int x, int y, int num, U32 places) {
   display_goto_xy(x, y);
   display_int(num, places);
}

void TextOut(int x, int y, const char *str) {
   display_goto_xy(x, y);
   display_string(str);
}

long test_TextOut() {

   int y;

   for (y = 0; y < 50; ++y) {
      // clear without update !? only clear buffer, this should be advantage for nxtOSEK
      display_clear(0);

      // x,y value is line not pixel! nxtOSEK use fast dma update in chars,lines!
      NumOut(0,0, 0, 1); NumOut(2,0, 1000, 4); TextOut(8,0, "int_Add");
      NumOut(0,1, 1, 1); NumOut(2,1, 1010, 4); TextOut(8,1, "int_Mult");
      NumOut(0,2, 2, 1); NumOut(2,2, 1020, 4); TextOut(8,2, "float_op");
      NumOut(0,3, 3, 1); NumOut(2,3, 1030, 4); TextOut(8,3, "rand_array");
      NumOut(0,4, 4, 1); NumOut(2,4, 1040, 4); TextOut(8,4, "matrx_algb");
      NumOut(0,5, 5, 1); NumOut(2,5, 1050, 4); TextOut(8,5, "arr_sort");
      NumOut(0,6, 6, 1); NumOut(2,6, 1060, 4); TextOut(8,6, "displ_txt");
      NumOut(0,7, 7, 1); NumOut(2,7, 1070, 4); TextOut(8,7, "testing...");

      display_update();
   }
   return 99;
}

U32 runtime[8];

void displayValues() {
   NumOut(0,0, 0, 1); NumOut(2,0, (int)runtime[0], 5); TextOut(8,0, "int_Add");
   NumOut(0,1, 1, 1); NumOut(2,1, (int)runtime[1], 5); TextOut(8,1, "int_Mult");
   NumOut(0,2, 2, 1); NumOut(2,2, (int)runtime[2], 5); TextOut(8,2, "float_op");
   NumOut(0,3, 3, 1); NumOut(2,3, (int)runtime[3], 5); TextOut(8,3, "rand_array");
   NumOut(0,4, 4, 1); NumOut(2,4, (int)runtime[4], 5); TextOut(8,4, "matrx_algb");
   NumOut(0,5, 5, 1); NumOut(2,5, (int)runtime[5], 5); TextOut(8,5, "arr_sort");
   NumOut(0,6, 6, 1); NumOut(2,6, (int)runtime[6], 5); TextOut(8,6, "displ_txt");
   NumOut(0,7, 7, 1); NumOut(2,7, (int)runtime[7], 5); TextOut(8,7, "testing...");
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////TASKS ///////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////


TASK(TaskMain) {
   unsigned long time0, x, y;
   float s;

   display_clear(1);

   TextOut(0, 0, "HaWe_Bench");
   TextOut(0, 1, "(C)H.Wunder 2013");
   TextOut(0, 3, "nxtOSEK port:");
   TextOut(0, 4, "Martin Aumair");
   TextOut(0, 5, "initializing...");

   systick_wait_ms(3000);

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

   display_clear(1);

   time0 = systick_get_ms();

   s = test_Int_Add();
   runtime[0] = systick_get_ms() - time0;


   time0 = systick_get_ms();
   s = test_Int_Mult();
   runtime[1] = systick_get_ms() - time0;


   time0 = systick_get_ms();
   s = test_float_math();
   runtime[2] = systick_get_ms() - time0;


   time0 = systick_get_ms();
   s = test_rand_MT();
   runtime[3] = systick_get_ms() - time0;


   time0 = systick_get_ms();
   s = test_matrix_math();
   runtime[4] = systick_get_ms() - time0;


   time0 = systick_get_ms();
   s = test_Sort();
   runtime[5] = systick_get_ms() - time0;


   time0 = systick_get_ms();
   s = test_TextOut();
   runtime[6] = systick_get_ms() - time0;


   /*
   time0 = systick_get_ms();
   s = test_graphics();
   runtime[7] = systick_get_ms() - time0;
*/
   runtime[7] = 0;

   displayValues();

   systick_wait_ms(10000);
   display_clear(1);
   y = 0;
   for (x = 0; x < 8; ++x) {
      y += runtime[x];
   }

   TextOut(0,0, "sum ms:");    NumOut(8,0, y, 7);
   TextOut(0,1, "benchmark:"); NumOut(8,1, 10000000/y, 7);

   TerminateTask();
}

}


Werte:

Code: Alles auswählen

integer add/subtr                   24
integer multiply/division         82
float operations                      430       
randomize Mersenne T.           56
matrix algebra (mult/det)        39
int array sort [500]                  2542
display text                            40
display grafics                         x


Ich denke bei NXC array sort läuft was falsch. Könnte mir sonst nicht erklären warum die Werte ca gleich zu nxtOSEK sind.

Bei den Textausgaben ist nxtOSEK eindeutig am schnellsten. Das liegt wohl daran das ich 2 große Vorteile nutze.
Einmal werden die Daten gepuffert und man kann selbst bestimmen wenn der LCD wirklich upgedated wird. (Daten sichtbar machen)
Bei beiden anderen Implementierungen wird nach jeder Ausgabe sofort auch der LCD upgedated (was in vielen Fällen einfach sinnlos ist)
Das Zweite ist das Daten zeilenweise gepuffert werden.
Projekte und Informationen auf meiner Website: http://roboticsaumair.jimdo.com/

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 19:54

das mit dem LCD Update und Puffern darf nicht sein, der Benchmark ist so angelegt, dass er wirklich alles schreiben oder zeichnen muss, denn es soll die echte Textausgabe- und Grafikleistung getestet werden.
Gepuffert werden darf nicht, es geht nicht nur ums ausrechnen, sondern v.a. ums echte ausgeben. Daher lasse ich auch nach jedem Durchgang den Bildschirm komplett löschen.

NXC verwendet irgendwelche low-level-FW-Routinen zum Sortieren, dass etwas schief läuft, lässt sich nicht ganz ausschließen - allerdings auch nicht beim shell sort, auch der könnte mal falsch arbeiten.
Ich habe allerdings schon sehr viel mit NXC-Arraysort praktisch gearbeitet, falsche Ergebnisse sind nie zu Tage getreten.
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 20:10

wenn nxtOSEK keine eingebaute Ellipse- und fillshape-Funktonen hast, müssten sie "von Hand" programmiert werden.
Das ist wie beim Sortieren:
ArraySort ist in NXC eingebaut, für C musste ich selber eine solche Funktion programmieren.

vllt kannst du ja John Hansens ANSI-C Grafik-Bibliothek durchforsten, ich bin sicher, er hat die ganzen Zeichenfunktionen da irgendwo vergraben! :)
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Martin0x5E
Schreibt super viel
Schreibt super viel
Beiträge: 496
Registriert: 17. Dez 2011 11:39
Wohnort: Österreich

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon Martin0x5E » 14. Dez 2013 20:33

Zum Sortieren:

Habe nicht gesehen das du in NXC die Standard-FW Funktion benutzt.
NXC verwendet zum Sortieren von Arrays Bubblesort. Vielleicht sollten wir dann auch Bubblesort implementieren.

wenn nxtOSEK keine eingebaute Ellipse- und fillshape-Funktonen hast, müssten sie "von Hand" programmiert werden.
Das ist wie beim Sortieren:
ArraySort ist in NXC eingebaut, für C musste ich selber eine solche Funktion programmieren.


NxtOSEK unterstütz allgemein keine solchen Funktionen. Ich bin seit ca 2 Monaten dabei eine Library für nxtOSEK zu schreiben die nxtOSEK extrem erweitern wird. (Dazu aber später mehr) :)
Habe schon alles bis auf Ellipse (Habe dafür noch keinen Sinn gesehen...)

das mit dem LCD Update und Puffern darf nicht sein, der Benchmark ist so angelegt, dass er wirklich alles schreiben oder zeichnen muss, denn es soll die echte Textausgabe- und Grafikleistung getestet werden.
Gepuffert werden darf nicht, es geht nicht nur ums ausrechnen, sondern v.a. ums echte ausgeben. Daher lasse ich auch nach jedem Durchgang den Bildschirm komplett löschen.


Es kann genauso sein das NXC oder der EV3 puffert. Da müsste man die Display-Treiber sehen damit man das sagen kann.
Bei nxtOSEK läuft eben nichts versteckt hinter den Kulissen. Man hat selbst die Kontrolle wenn der Treiber die Pins "befeuert".
Projekte und Informationen auf meiner Website: http://roboticsaumair.jimdo.com/

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 20:34

vor allem T hat einen ganz bestimmten Zweck:
die zu sortierenden Arrays sollten eigtl in der original-Form bleiben (wie bei NXC), es sollte nur eine sortierte Kopie als T zurückgegeben werden.
Das habe ich bis jetzt aber auch für BCC/C nicht so gemacht.
Array-Felder einzeln von A nach T kopieren und dann T sortieren ist viel zu langsam, daher habe ich es gestrichen - man müsste eine Art "Block-Memory-Kopie" machen, so macht es wohl auch NXC. So weit bin ich aber noch nicht, vllt findet sich aber noch ein guter sort-alg in einer guten C-lib, wo das mit drin ist.

Sobald ich's gefunden habe, werde ich zusehen, dass ich es implementiert kriege. Solange lasse ich T drin.
O hatte mal einen ähnlichen zweck, auch das lasse ich solange für spätere Kompatibilitätsgründe erstmal drin, schadet ja nicht.
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 20:35

laut JH's eigener Aussage verwendet er Shellsort, er hat es mir auf meine Frage persönlich so beantwortet.
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Martin0x5E
Schreibt super viel
Schreibt super viel
Beiträge: 496
Registriert: 17. Dez 2011 11:39
Wohnort: Österreich

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon Martin0x5E » 14. Dez 2013 20:45

laut JH's eigener Aussage verwendet er Shellsort, er hat es mir auf meine Frage persönlich so beantwortet.


Ah stimmt, hab irgendwie was falsches im Kopf gehabt.
Dann ist das von JH wahrscheinlich auch eine direkt Implementation auf dem Prozessor.
Interessant nur wie er die Arrays aus NXC in ein C-Array schickt.
Projekte und Informationen auf meiner Website: http://roboticsaumair.jimdo.com/

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5394
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Benchmark Test NXT(NXC) vs. EV3(BCC-C)

Beitragvon HaWe » 14. Dez 2013 20:57

man muss es für den benchmark eben so schnell wie programmtechnisch möglich machen!
Die Hardware soll maximal gestresst werden!

(ps wenn der Bildschirmpuffer überläuft oder nichts mehr annnimmt, dann ist es eben so, genau unter diesen Bedingungen soll getestet werden)
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞®
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E


Zurück zu „Allgemeines zu Lego Mindstorms NXT und EV3“

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 17 Gäste

Lego Mindstorms EV3, NXT und RCX Forum : Haftungsauschluss