not already quite Mindstorms yet .... not yet....
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);
}