// -*- C++ -*-
#define N 5
#define M 10
#define MAX_ITER 20
#define RIS "/tmp/risultato.txt"

/***************************************************************/
/*                                                             */
/* Test della distribuzione on_demand su una topologia array.  */
/*                                                             */
/* Il parmod elabora ha topologia array.                       */
/*                                                             */
/* L'attributo replicato e' un array ad una dimensione         */
/*                                                             */
/**************************************************************/

generic main() {
  stream long[M] A;
  stream long[M] B;

  genera    (output_stream A);
  elabora   (input_stream A output_stream B);
  stampa    (input_stream B);
} 
 

genera (output_stream long A[M]) {
  Fgenera (output_stream A);
}


proc Fgenera (output_stream long A[M]) 
inc<"iostream">
$c++{
  long tmp_A[M];

  // messaggio di partenza x il regression test
  std::cerr << "STARTING fgen" << std::endl;
  
  for (int k=0; k<MAX_ITER; k++) {
    for (int i=0; i<M; i++) 
      tmp_A[i] = i;
    assist_out (A, tmp_A);
  }
}c++$


parmod elabora (input_stream long A[M] output_stream long B[M]) {

  topology array [i:N] Pv;

  /* bug del module builder risolto:
     vedeva B_ come un intero e non come un array */
  attribute long B_[M] replicated;
  stream long ris[M];
  
  do input_section {
    guard1: on , , A {
      distribution A on_demand to Pv;
    }
  } while (true)
       
  virtual_processors {
    elab (in guard1 out ris) {
      VP i {
	  Felab (in A out B_);
	  assist_out (ris, B_); 
      }
    }
  }
 
  output_section {
    collects ris from ANY Pv {
      assist_out(B, ris);
    }<>;
  } 
}


stampa (input_stream long B[M])
 
inc<"fstream","iostream">
$c++{
  static std::ofstream f;
  static int  count = 0;
  static int     ok = 0;

  if (count == 0) {
    f.open (RIS);
  }

  /* stampa e verifica del risultato */
  for (int i=0; i<M; i++) {
    f << B[i] << std::endl;
    if (B[i] != i) ok = -1;
  }
  count++;
  
  // messaggio di terminazione x il regression test
  if (count >= MAX_ITER) {
    if (ok==0) 
      std::cerr << "ENDING with SUCCESS fine array_on_demand_attrib_array_replic.ast" << std::endl;
    else std::cerr << "ENDING with FAILURE fine array_on_demand_attrib_array_replic.ast" << std::endl;
    f.close();
  }
}c++$


proc Felab (in long A[M] out long B_[M])
 
inc<"iostream">
$c++{
  for (int i=0; i<M; i++)
    B_[i] = A[i];
}c++$