Référence du fichier benchmark.cpp

#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <setjmp.h>
#include <iostream>
#include <wchar.h>
#include <vector>
#include <map>
#include <fstream>
#include <sstream>
#include <string>

Fonctions
bool	doInteger (int parameter)
	Calculs sur les entiers.
bool	doLong (int parameter)
	Calculs sur les entiers longs.
bool	doDouble (int parameter)
	Calculs sur les doubles.
bool	doIO (int parameter)
	Ecriture d'un fichier d'un pattern composé d'une ligne de lettres contenant des caractères accentués.
bool	doMatrix (int parameter)
	Simple multiplication de deux matrices carrées.
bool	doVector (int parameter)
	Création de deux vecteurs et divers opérations pour passer des éléments de l'un à l'autre.
bool	doSort (int n)
	Tri d'un tableau d'ordre inversé par rapport à l'objectif.
bool	doException (int parameter)
	Génére un nombre important d'exceptions dans une boucle.
bool	doHash (int parameter)
	Ici on cré une table de hash<int,int> initialisé à FACTOR*parameter valeurs entières.
bool	doTrigo (int parameter)
	Fonctions mathématiques et trigonométriques.
bool	doConcatenation (int parameter)
	Concaténation de n chaines en une seule.
bool	doLoop (int parameter)
	6 boucles imbriquées.
int	main (int argc, char *argv[])
	Procédure principale de lancement d'un test.

---

Documentation des fonctions

bool doConcatenation

(

int

parameter

)

Concaténation de n chaines en une seule.

Pour être plus juste par rapport à l'immutabilité des chaînes dans les langages Java et C#, ce sont les versions bufferisées qui sont utilisées.

Paramètres:

parameter

nombre de concaténations.

Renvoie:

true si c'est ok

                                    {
  static const string PATTERN= "éàôabcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefgh";
  string result="";
  for (int i=0; i < parameter; i++) {
    result+=PATTERN;
  }
  
  return result.length() == parameter*PATTERN.length() && result.substr(result.length() - PATTERN.length()) == PATTERN;
}

bool doDouble

(

int

parameter

)

Calculs sur les doubles.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

                             {
  double result = 1;
  for (int i = 1; i < parameter; i++) {
    result -= i;
    result += i;
    result *= i;
    result /= i;
  }
  return result == 1;
}

bool doException

(

int

parameter

)

Génére un nombre important d'exceptions dans une boucle.

Paramètres:

parameter

nombre d'itérations.

Renvoie:

true si le test est validé.

                                {
  int count=0;
  for (int i=0; i < parameter; i++) {
    try
    {
      if ((i % 2) == 0) {
        exception e;
        throw e;
      }
    }
    catch (exception &e)
    {
      count++;
    }
  }
  return count==parameter/2;
}

bool doHash

(

int

parameter

)

Ici on cré une table de hash<int,int> initialisé à FACTOR*parameter valeurs entières.

Ensuite on énumère ces valeurs pour les ajouter dans une seconde hash avec une clef % FACTOR.

Paramètres:

parameter

La taille de la hash / FACTOR

Renvoie:

true si ok

                           {
  const int FACTOR = 100;
  const int ITEMS = FACTOR*parameter;
  map <int, int> hash1;
  map <int, int> hash2;
  int c = 0;
  
  for (int i=0; i<ITEMS; i++) {
    hash1.insert(map <int, int>::value_type(i, i) );
  }
  
  map <int, int> :: iterator h1_it;
  map <int, int> :: iterator h2_it;
  for (h1_it = hash1.begin() ; h1_it != hash1.end(); h1_it++) {
    int key=h1_it->first;
    int v1 = (int) h1_it->second;
    int key2=key % FACTOR;
    h2_it=hash2.find(key2);
    if (hash2.end()!=h2_it) {
      int v2 = (int) h2_it->second;
      v1 += v2;
    }
    hash2.insert(map <int, int>::value_type(key2, v1) );
  }
  return hash2.size()==FACTOR;
}

bool doInteger

(

int

parameter

)

Calculs sur les entiers.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

                              {
  int result = 1;
  for (int i = 1; i < parameter; i++) {
    result -= i;
    result += i;
    result *= i;
    result /= i;
  }
  return result == 1;
}

bool doIO

(

int

parameter

)

Ecriture d'un fichier d'un pattern composé d'une ligne de lettres contenant des caractères accentués.

Ensuite relecture du même fichier ligne par ligne.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

                         {
  const string PATTERN= "éàôabcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefgh";
  const string FILE_NAME="../tmp/test_cpp.txt";
  
  ofstream writer(FILE_NAME.c_str());
  for (int i=0; i<parameter; i++) {
    writer << PATTERN << endl;
  }
  writer.close();
  
  ifstream reader(FILE_NAME.c_str());
  string line;
  for (int i=0; i<parameter; i++) {
    reader >> line;
    if (line != PATTERN) {
      return false;
    }
  }
  reader.close();
  
  return true;
}

bool doLong

(

int

parameter

)

Calculs sur les entiers longs.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

                           {
  long result = 1;
  for (int i = 1; i < parameter; i++) {
    result -= i;
    result += i;
    result *= i;
    result /= i;
  }
  return result == 1;
}

bool doLoop

(

int

parameter

)

6 boucles imbriquées.

Paramètres:

parameter

nombre d'itérations à chaque étage

Renvoie:

True si le test est validé

                           {
  int a, b, c, d, e, f;
  double x = 0;
  for (a = 0; a <= parameter; a++) {
    for (b = 0; b <= parameter; b++) {
      for (c = 0; c <= parameter; c++) {
        for (d = 0; d <= parameter; d++) {
          for (e = 0; e <= parameter; e++) {
            for (f = 0; f <= parameter; f++) {
              x = a + b + c + d + e + f;
            }
          }
        }
      }
    }
  }
  return x == 6 * parameter;
}

bool doMatrix

(

int

parameter

)

Simple multiplication de deux matrices carrées.

L'utilisation des (new) permet d'être plus juste avec les autres langages.

Paramètres:

parameter

taille de la matrice

Renvoie:

true si tout est ok

                             {
  // Create the the matrix
  int **m1= new int*[parameter];
  int **m2= new int*[parameter];
  int count = 1;
  for (int i = 0; i < parameter; i++) {
    m1[i] = new int[parameter];
    m2[i] = new int[parameter];
    for (int j = 0; j < parameter; j++) {
      m1[i][j] = count;
      m2[i][j] = 0;
      count++;
    }
  }
  
  
  // Create inversion matrix
  for (int i = 0; i < parameter; i++) {
    m2[i][parameter - i - 1] = 1;
  }
  
  
  // Multiply them
  int **mm= new int*[parameter];
  ;
  for (int i = 0; i < parameter; i++) {
    mm[i] = new int[parameter];
    for (int j = 0; j < parameter; j++) {
      int val = 0;
      for (int k = 0; k < parameter; k++) {
        val += m1[i][k] * m2[k][j];
      }
      mm[i][j] = val;
    }
  }
  
  
  // Check inversion
  for (int i = 0; i < parameter; i++) {
    for (int j = 0; j < parameter; j++) {
      if (mm[i][j] != m1[i][parameter - j - 1]) {
        return false;
      }
    }
  }
  
  // Free memory
  for (int i = 0; i < parameter; i++) {
      delete [] m1[i];
      delete [] m2[i];
      delete [] mm[i];
  }
  delete [] m1;
  delete [] m2;
  delete [] mm;
  
  return true;
}

bool doSort

(

int

n

)

Tri d'un tableau d'ordre inversé par rapport à l'objectif.

Paramètres:

n

Taille du tableau

Renvoie:

true si le test est validé.

                   {
  int *ra = new int[n + 1];
  for (int i = 0; i <= n; i++) {
    ra[i] = n - i;
  }
  int i, j;
  int ir = n;
  int l = (n >> 1) + 1;
  int rra;
  
  for (;;) {
    if (l > 1) {
      rra = ra[--l];
    } else {
      rra = ra[ir];
      ra[ir] = ra[1];
      if (--ir == 1) {
        ra[1] = rra;
        break;
      }
    }
    i = l;
    j = l << 1;
    while (j <= ir) {
      if (j < ir && ra[j] < ra[j + 1]) {
        ++j;
      }
      if (rra < ra[j]) {
        ra[i] = ra[j];
        j += i = j;
      } else {
        j = ir + 1;
      }
    }
    ra[i] = rra;
  }
  for (i = 1; i < n; i++) {
    if (ra[i] > ra[i + 1]) {
      return false;
    }
  }
  return true;
}

bool doTrigo

(

int

parameter

)

Fonctions mathématiques et trigonométriques.

Paramètres:

parameter

itéartions sur le test

Renvoie:

true si ok

                            {
  
  double sine = 0.0;
  double cosine = 0.0;
  double tangent = 0.0;
  double logarithm = 0.0;
  double squareRoot = 0.0;
  double cumul = 0;
  double full = 8 * atan(1);
  for (int i = 0; i < parameter; i++) {
    double angle = 0;
    while (angle < full) {
      sine = sin(angle);
      cosine = cos(angle);
      tangent = tan(angle);
      cumul += sine + cosine + tangent;
      angle++;
    }
    logarithm = log(i+1);
    squareRoot = sqrt(i+1);
    cumul += logarithm + squareRoot;
  }
  return cumul != 0;
}

bool doVector

(

int

parameter

)

Création de deux vecteurs et divers opérations pour passer des éléments de l'un à l'autre.

Paramètres:

parameter

taille des vecteurs.

Renvoie:

true si le test est validé.

                             {
  vector<int> Li1;
  for (int i = 0; i < parameter; i++)
    Li1.push_back(i); //addlast

  vector<int> Li2=Li1;
  vector<int> Li3;
  
  while (!Li2.empty()) {
    Li3.push_back((int)*Li2.begin() ); //addlast
    Li2.erase(Li2.begin());
  }
  
  while (!Li3.empty()) {
    Li2.push_back( (int)*(Li3.end()-1) ); //addlast
    Li3.erase(Li3.end()-1);
  }
  
  vector<int> tmp;
  while (!Li1.empty()) {
    tmp.insert(tmp.begin() , (int)Li1[0]); //addfirst
    Li1.erase(Li1.begin());
  }
  Li1 = tmp;

  return (int)(Li1[0]) == parameter-1;
}

int main	(	int	argc,
		char *	argv[]
	)

Procédure principale de lancement d'un test.

                                 {
  char * testName = argv[1];
  int parameter=atoi(argv[2]);
  bool result = false;
  clock_t startTime = clock();
  
  if (strcmp("Double", testName)==0) {
    result=doDouble(parameter);
  } else if (strcmp("Long", testName)==0) {
    result=doLong(parameter);
  } else if (strcmp("Integer", testName)==0) {
    result=doInteger(parameter);
  } else if (strcmp("Trigo", testName)==0) {
    result=doTrigo(parameter);
  } else if (strcmp("Loop", testName)==0) {
    result=doLoop(parameter);
  } else if (strcmp("IO", testName)==0) {
    result=doIO(parameter);
  } else if (strcmp("Exception", testName)==0) {
    result=doException(parameter);
  } else if (strcmp("Hash", testName)==0) {
    result=doHash(parameter);
  } else if (strcmp("Concatenation", testName)==0) {
    result=doConcatenation(parameter);
  } else if (strcmp("Matrix", testName)==0) {
    result=doMatrix(parameter);
  } else if (strcmp("Vector", testName)==0) {
    result=doVector(parameter);
  } else if (strcmp("Sort", testName)==0) {
    result=doSort(parameter);
  }
  clock_t stopTime = clock();
  if (!result) {
    wprintf(L"-1\n");
  } else {
    double elapsedTime = (stopTime - startTime) / (CLOCKS_PER_SEC / (double) 1000.0);
    long l = (long)elapsedTime;
    wprintf(L"%d\n",l);
  }
  return 0;
}