#
# Programme developpe par Guy Tremblay, Professeur au dept. d'informatique de l'UQAM,
# dans le cadre des cours INF7440 (2002, 2003, 2004) et INF5170 (2006, 2008).
#
# Tous droits reserves.
#
#
# Solution au laboratoire #2.


resource labo2()

  int nbProcs;

  # Generation (aleatoire) des elements du tableau a.
  procedure generer( ref int a[*], int n ) {
    for [i = 1 to n] {
      a[i] = i # int(random(1, N));
    }
  }

  # Impression des elements du tableau a.
  procedure imprimer( int a[*], int n ) {
    for [i = 1 to n-1] {
      writes( a[i], ", " );
    }
      write( a[n] );
  }


  # Procedures auxiliaires pour calcul des bornes.

  procedure inf( int i, int n, int nbProcs ) returns int r
  # Borne inferieure du i-ieme intervalle pour n elements avec nbProcs processeurs.
  { r = (i-1) * (n / nbProcs) + 1; }
  
  procedure sup( int i, int n, int nbProcs ) returns int r
  # Borne superieure du i-ieme intervalle pour n elements avec nbProcs processeurs..
  { r = min( i * (n / nbProcs), n ); }


  # Procedure auxiliaire pour appel dans le co.
  procedure somme_tranche( ref int a[*], ref int b[*], ref int c[*], int i, int j )
  {
    for [k = i to j] { 
       c[k] = a[k] + b[k]; 
    }
  }

  procedure somme( int a[*], int b[*], ref int c[*], int n )
  {
    # On suppose nbProcs connu au niveau global. 
    if ( nbProcs == 0 ) {
      somme_tranche( a, b, c, 1, n );
    } else {
      co [i = 1 to nbProcs]
        somme_tranche( a, b, c, inf(i, n, nbProcs), sup(i, n, nbProcs) );
      oc 
    }
  }


  ############################################################
  # Programme principal
  ############################################################

  # Lecture et verification des arguments.
  if (numargs() < 3) {
    write( "Usage:" );
    write( "  a.out taille nbRepetitions nbProcessus" );
    stop(1);
  }
  int n; getarg(1, n); 
  if ( n <= 0 ) {
    write("*** Erreur: n <= 0" );
    stop(1);
  }
  int nbRepetitions;
  getarg(2, nbRepetitions);
  if ( nbRepetitions <= 0 ) {
    write("*** Erreur: Le nombre de repetitions doit etre positif" );
    stop(1);
  }
  getarg(3, nbProcs)
  if ( nbProcs < 0 ) {
    write("*** Erreur: nbProcs < 0" );
    stop(1);
  }

  #####################################################################
  int a[n], b[n], c[n]; 


  # Generation aleatoire des elements
  generer(a, n);
  generer(b, n);

  # Calculs (repetitifs) de la somme.
  int tempsTotal = 0;
  int tempsMin = high(int);
  int tempsMax = low(int);

  int tDebut, tFin;
  for [i = 1 to nbRepetitions] {
    tDebut = age();
    somme( a, b, c, n );
    tFin = age();
    #write( "temps (#", i, "): ", tFin - tDebut );
    int temps = tFin - tDebut;
    tempsTotal += temps;
    tempsMin = min( temps, tempsMin );
    tempsMax = max( temps, tempsMax );
  }

  real moyenne = (1.0 * tempsTotal) / nbRepetitions;
  real et = (tempsMax - tempsMin) / 2.0;
  printf( "%8.0f +/- %6.0f  [%d..%d]\n", moyenne, et, tempsMin, tempsMax  );

  # Impression des resultats
  /*
  write( "c = a + b" );
  writes( "a:: " ); imprimer( a, n );
  writes( "b:: " ); imprimer( b, n );
  writes( "c:: " ); imprimer( c, n );
  */
end