Référence de la classe Benchmark

Liste de tous les membres

Fonctions membres publiques statiques
static boolean	doConcatenation (int parameter)
	Concaténation de n chaines en une seule.
static boolean	doDouble (int parameter)
	Calculs sur les doubles.
static boolean	doException (int parameter)
	Génére un nombre important d'exceptions dans une boucle.
static boolean	doHash (int parameter)
	Ici on cré une table de hash<int,int> initialisé à FACTOR*parameter valeurs entières.
static boolean	doInteger (int parameter)
	Calculs sur les entiers.
static boolean	doIO (int parameter) throws IOException
	Ecriture d'un fichier d'un pattern composé d'une ligne de lettres contenant des caractères accentués.
static boolean	doLong (int parameter)
	Calculs sur les entiers longs.
static boolean	doLoop (int parameter)
	6 boucles imbriquées.
static boolean	doMatrix (int parameter)
	Simple multiplication de deux matrices carrées.
static boolean	doSort (int n)
	Tri d'un tableau d'ordre inversé par rapport à l'objectif.
static boolean	doThreads (int parameter)
	Composition d'un anneau de N threads servant de relai de signal.
static boolean	doTrigo (int parameter)
	Fonctions mathématiques et trigonométriques.
static boolean	doVector (int parameter)
	Création de deux vecteurs et divers opérations pour passer des éléments de l'un à l'autre.
static void	main (String[] args) throws Exception
	Procédure principale de lancement d'un test.
Classes
class	Node
	Classe utilisée pour le test doTreads. Plus de détails...

---

Documentation des fonctions membres

static boolean doConcatenation

(

int

parameter

)

[static]

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

                                                       {
    final String PATTERN = "éàôabcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefgh";
    StringBuffer result = new StringBuffer();
    for (int i = 0; i < parameter; i++) {
      result.append(PATTERN);
    }
    return result.length() == parameter * PATTERN.length()
        && result.substring(result.length() - PATTERN.length()).equals(PATTERN);
  }

Voici le graphe d'appel pour cette fonction :

static boolean doDouble

(

int

parameter

)

[static]

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

Voici le graphe d'appel pour cette fonction :

static boolean doException

(

int

parameter

)

[static]

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 counter = 0;
    for (int i = 0; i < parameter; i++) {
      if (i % 2 == 0) {
        try {
          throw new Exception();
        } catch (Exception e) {
          counter++;
        }
      }
    }
    return counter == parameter / 2;
  }

Voici le graphe d'appel pour cette fonction :

static boolean doHash

(

int

parameter

)

[static]

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

                                              {
    final int FACTOR = 100;
    final int ITEMS = parameter * FACTOR;
    HashMap hash1 = new HashMap();
    HashMap hash2 = new HashMap();

    Integer integer;
    for (int i = 0; i < ITEMS; i++) {
      integer = new Integer(i);
      hash1.put(integer, integer);
    }

    Iterator iterator = hash1.entrySet().iterator();

    while (iterator.hasNext()) {
      Map.Entry entry = (Map.Entry) iterator.next();
      int key = ((Integer) entry.getKey()).intValue();
      int key2 = key % FACTOR;
      int v1 = ((Integer) entry.getValue()).intValue();
      Integer v2 = (Integer) hash2.get(new Integer(key2));
      if (v2 != null) {
        v1 += v2.intValue();
      }
      hash2.put(new Integer(key2), new Integer(v1));
    }
    return hash2.size() == FACTOR;
  }

Voici le graphe d'appel pour cette fonction :

static boolean doInteger

(

int

parameter

)

[static]

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

Voici le graphe d'appel pour cette fonction :

static boolean doIO

(

int

parameter

)

throws IOException [static]

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

                                                               {
    final String PATTERN = "éàôabcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefgh";
    final File FILENAME = new File("../tmp/TestJava.txt");

    // long time = System.currentTimeMillis();
    BufferedOutputStream writer = new BufferedOutputStream(new FileOutputStream(FILENAME));
    byte[] bytes = (PATTERN + "\n").getBytes();
    for (int i = 0; i < parameter; i++) {
      writer.write(bytes);
    }
    writer.close();
    // System.out.println(System.currentTimeMillis() - time);
    // time = System.currentTimeMillis();
    BufferedReader reader = new BufferedReader(new FileReader(FILENAME));
    String line = "";
    for (int i = 0; i < parameter; i++) {
      line = reader.readLine();
      if (!line.equals(PATTERN)) {
        return false;
      }
    }
    reader.close();
    // System.out.println(System.currentTimeMillis() - time);
    return true;

  }

Voici le graphe d'appel pour cette fonction :

static boolean doLong

(

int

parameter

)

[static]

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

Voici le graphe d'appel pour cette fonction :

static boolean doLoop

(

int

parameter

)

[static]

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

Voici le graphe d'appel pour cette fonction :

static boolean doMatrix

(

int

parameter

)

[static]

Simple multiplication de deux matrices carrées.

Paramètres:

parameter

taille de la matrice

Renvoie:

true si tout est ok

                                                {
    // Create the the matrix
    int[][] m1 = new int[parameter][parameter];
    int[][] m2 = new int[parameter][parameter];
    int count = 1;
    for (int i = 0; i < parameter; i++) {
      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][parameter];
    for (int i = 0; i < parameter; i++) {
      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;
        }
      }
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

static boolean doSort

(

int

n

)

[static]

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

Voici le graphe d'appel pour cette fonction :

static boolean doThreads

(

int

parameter

)

[static]

Composition d'un anneau de N threads servant de relai de signal.

Le signal en question est un entier dont la valeur est 1000xNombreThreads. Le message est passé d'un thread à l'autre en étant à chaque fois décrémenté. Lorsqu'un thread reçoit une valeur de signal négative, il le passe à son voisin et meurt.

Paramètres:

n

Nombre de threads

Renvoie:

true si le test est validé.

                                                 {
    int threadCount = parameter - 1;
    int factor = 1000;
    int signal = factor * parameter;
    Node firstNode = new Node();

    // Make the ring
    Node previousNode = firstNode;
    for (int iNode = 0; iNode < threadCount; iNode++) {
      Node currentNode = new Node();
      if (previousNode != null) {
        currentNode.setNextNode(previousNode);
      } else {
        firstNode = currentNode;
      }
      currentNode.start();
      previousNode = currentNode;
    }

    // Close the ring
    firstNode.setNextNode(previousNode);

    while (true) {
      if (Node.ALIVES.size() == threadCount) {
        break;
      }
      try {
        Thread.sleep(1);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    firstNode.initialize(signal);
    return firstNode.received == factor + 1;
  }

Voici le graphe d'appel pour cette fonction :

Voici le graphe d'appel pour cette fonction :

static boolean doTrigo

(

int

parameter

)

[static]

Fonctions mathématiques et trigonométriques.

Paramètres:

parameter

itéartions sur le test

Renvoie:

true si ok

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

Voici le graphe d'appel pour cette fonction :

static boolean doVector

(

int

parameter

)

[static]

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

                                                {
    ArrayList Li1 = new ArrayList();
    for (int i = 0; i < parameter; i++) {
      Li1.add(new Integer(i));
    }

    ArrayList Li2 = new ArrayList(Li1);
    ArrayList Li3 = new ArrayList();

    while (!Li2.isEmpty()) {
      Li3.add(Li2.remove(0));
    }

    while (!Li3.isEmpty()) {
      int i = Li3.size() - 1;
      Li2.add(Li3.get(i));
      Li3.remove(i);
    }

    ArrayList tmp = new ArrayList();
    while (!Li1.isEmpty()) {
      tmp.add(0, Li1.remove(0));
    }

    Li1 = tmp;

    return ((Integer) Li1.get(0)).intValue() == parameter - 1;
  }

Voici le graphe d'appel pour cette fonction :

static void main

(

String[]

args

)

throws Exception [static]

Procédure principale de lancement d'un test.

                                                          {
    int parameter = Integer.parseInt(args[1]);
    String testName = args[0];
    boolean result = false;
    long startTime = System.currentTimeMillis();
    if (testName.equals("Threads")) {
      result = doThreads(parameter);
    } else if (testName.equals("Double")) {
      result = doDouble(parameter);
    } else if (testName.equals("Long")) {
      result = doLong(parameter);
    } else if (testName.equals("Integer")) {
      result = doInteger(parameter);
    } else if (testName.equals("Trigo")) {
      result = doTrigo(parameter);
    } else if (testName.equals("Loop")) {
      result = doLoop(parameter);
    } else if (testName.equals("IO")) {
      result = doIO(parameter);
    } else if (testName.equals("Exception")) {
      result = doException(parameter);
    } else if (testName.equals("Hash")) {
      result = doHash(parameter);
    } else if (testName.equals("Concatenation")) {
      result = doConcatenation(parameter);
    } else if (testName.equals("Vector")) {
      result = doVector(parameter);
    } else if (testName.equals("Matrix")) {
      result = doMatrix(parameter);
    } else if (testName.equals("Sort")) {
      result = doSort(parameter);
    }
    long stopTime = System.currentTimeMillis();
    if (!result) {
      System.out.println("-1");
    } else {
      long delay = stopTime - startTime;
      System.out.println(delay);
    }
    System.exit(0);
  }

Voici le graphe d'appel pour cette fonction :

---

La documentation de cette classe a été générée à partir du fichier suivant :

• Benchmark.java