who already owns a Intel Galileo Board ?

Discuss anything and everything. Keep it clean (or else).

who already owns a Intel Galileo Board ?

Postby HaWe » 09 Dec 2014, 11:16

hi,
not already quite Mindstorms yet .... not yet.... 8-)
any member in this forum who already owns a Intel Galileo Board ?

http://www.aliexpress.com/item/Intel-Ga ... 94699.html

http://www.cooking-hacks.com/documentat ... les-boards

if anyone is around:


As the Galileo is Arduino-software compatible:
could you please test this following Arduino Sketch benchmark code on the Galileo and please report the results?
No code changes should be necessary!

Code: Select all
// hw brickbench
// benchmark test for NXT/EV3 and similar Micro Controllers
// PL: Sketch 1.5.6-r2
// platform: Arduino (u.a. Mega 2560, Due)
// 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.0004



#define TimerMS() millis()

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, float *A, float *B, float *C) {
   int i, j, s;
   for (i = 0; i < N; ++i) {
      for (j = 0; j < K; ++j) {
         C[i*K+j] = 0;
         for (s = 0; s < M; ++s) {
            C[i*K+j] = C[i*K+j] + A[i*N+s] * B[s*M+j];
         }
      }
   }
}


// matrix determinant

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

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

    A[0][0]=1;   A[0][1]=3;
    A[1][0]=2;   A[1][1]=4;
    MatrixDet(2, A[0]);                          // <<<<<<<<<<<<<<<<<<<

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

    MatrixDet(3, S[0]);                          // <<<<<<<<<<<<<<<<<<<

  }

  s=(S[0][0]*S[1][1]*S[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;
}

inline void displayValues() {

  char buf[120];

    sprintf (buf, "%3d %4d  int_Add",    0, runtime[0]); Serial.println( buf);
    sprintf (buf, "%3d %4d  int_Mult",   1, runtime[1]); Serial.println( buf);
    sprintf (buf, "%3d %4d  float_op",   2, runtime[2]); Serial.println( buf);
    sprintf (buf, "%3d %4d  randomize",  3, runtime[3]); Serial.println( buf);
    sprintf (buf, "%3d %4d  matrx_algb", 4, runtime[4]); Serial.println( buf);
    sprintf (buf, "%3d %4d  arr_sort",   5, runtime[5]); Serial.println( buf);
   
   
}


int test(){

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

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


  // LcdClearDisplay();

  time0= TimerMS();;
  s=test_Int_Add();
  runtime[0]=TimerMS()-time0;
  sprintf (buf, "%3d %4d  int_Add",    0, runtime[0]); Serial.println( buf);

  time0=TimerMS();
  s=test_Int_Mult();
  runtime[1]=TimerMS()-time0;
  sprintf (buf, "%3d %4d  int_Mult",   1, runtime[1]); Serial.println( buf);

  time0=TimerMS();
  s=test_float_math();
  runtime[2]=TimerMS()-time0;
  sprintf (buf, "%3d %4d  float_op",   2, runtime[2]); Serial.println( buf);

  time0=TimerMS();
  s=test_rand_MT();
  runtime[3]=TimerMS()-time0;
  sprintf (buf, "%3d %4d  randomize",  3, runtime[3]); Serial.println( buf);

  time0=TimerMS();
  s=test_matrix_math();
  runtime[4]=TimerMS()-time0;
  sprintf (buf, "%3d %4d  matrx_algb", 4, runtime[4]); Serial.println( buf);


  time0=TimerMS();
  s=test_Sort();
  runtime[5]=TimerMS()-time0;
  sprintf (buf, "%3d %4d  arr_sort",   5, runtime[5]); Serial.println( buf);
 
  // lcd display text / graphs  not performed!
  runtime[6]=0;
  runtime[7]=0;

  Serial.println();
 
  y = 0;
  for (x = 0; x < 8; ++x) {
      y += runtime[x];
  }
 
  sprintf (buf, "gesamt ms: %u ", y);           Serial.println( buf);
  sprintf (buf, "benchmark: %u ", 50000000/y ); Serial.println( buf);

  return 1;

}



void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
   char  buf[120];
  // put your main code here, to run repeatedly:
  test();
  sprintf (buf, "Ende HaWe brickbench");           Serial.println( buf);
  while(1);
}
User avatar
HaWe
 
Posts: 2500
Joined: 04 Nov 2014, 19:00

Re: who already owns a Intel Galileo Board ?

Postby Stryker295 » 10 Dec 2014, 00:57

This actually looks really awesome! Wish I could help.
—Jag
User avatar
Stryker295
 
Posts: 46
Joined: 29 Sep 2014, 09:53
Location: Arizona, USA


Return to Off-Topic

Who is online

Users browsing this forum: No registered users and 3 guests

cron