// -*- C++ -*-

/* ------------------------------------------------------------ */
/* In questo esempio e' testata la possibilita' di avere        */
/* il non determinismo su due canali in un parmod none.         */
/* Il grafo e' formato da due sequenziali, un parmod e un       */
/* sequenziale.                                                 */
/* ------------------------------------------------------------ */

 
 

#define N 10
#define MAX_ITER1 10   
#define MAX_ITER2 10   
#define FILE_OUT "/tmp/risultato.txt"


typedef struct
{
  long x;
  long y;
} T_cart;
 

generic main()
{
  stream T_cart[N] A;
  stream long A1;
  stream T_cart[N] B;

  genera1   (output_stream A);
  genera2   (output_stream A1);
  elabora   (input_stream A, A1  output_stream B);
  stampa    (input_stream B);
} 
 

genera1(output_stream T_cart A[N]) {
  Fgenera1(output_stream A);
}


proc Fgenera1(output_stream T_cart A[N])
 
inc<"iostream">
$c++{
  T_cart tmp_A[N];
  
  // messaggio di partenza x il regression test
  std::cerr << "STARTING fgen1" << std::endl;

  for (int k=0; k<MAX_ITER1; k++) {
    for (int i=0; i<N; i++) {
      tmp_A[i].x =  i+(k/MAX_ITER1);
      tmp_A[i].y = (i+(k/MAX_ITER1)) * (i+(k/MAX_ITER1));
    }
    assist_out (A, tmp_A);
  }
}c++$


genera2(output_stream long A1) {
  Fgenera2(output_stream A1);
}


proc Fgenera2(output_stream long A1)
 
inc<"iostream">
$c++{
  static long c = 0;
  
  // messaggio di partenza x il regression test
  std::cerr << "STARTING fgen2" << std::endl;

  for(int k=0; k<MAX_ITER2; k++) {
    assist_out(A1, c);
    c++;
  }
}c++$


parmod elabora(input_stream T_cart A[N], long A1 output_stream T_cart B[N]) {
  topology none Pv;
  
  do input_section {
    guard1: on , , A {
      distribution A on_demand to Pv;
    }
    guard2: on , , A1 {
      distribution A1 on_demand to Pv;
    }
  } while(true)
  
  virtual_processors {
    elab(in guard1 out B) {
      VP {
	Felab1(in A output_stream B);
      }
    }
    elab1(in guard2) {
      VP {
	Felab2(in A1);
      }
    }
  }
 
  output_section {
    collects B from ANY Pv;
  } 
}


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


  if (file_aperto == -1) {
    f.open (FILE_OUT);
    file_aperto = 0;
  }
  
  for(int i=0; i<N; i++)
    f << B[i].x << " " << B[i].y << std::endl;
  f << std::endl << std::endl;

  // verifica del risultato
  for (int i=0; i<N; i++) {
    if (B[i].y != -((int)(i+(count/MAX_ITER1)))) ok = -1;
    if (B[i].x != ((int)((i+(count/MAX_ITER1)) * (i+(count/MAX_ITER1))))) ok = -1;
  }
    
  count++;
  
  if (count >= MAX_ITER1) {
    f.close();
    
    // messaggio di terminazione x il regression test
    if (ok==0) 
      std::cerr << "ENDING with SUCCESS nondeterminismo.ast su file " << FILE_OUT << std::endl;
    else 
      std::cerr << "ENDING with FAILURE nondeterminismo.ast su file " << FILE_OUT << std::endl;
  }
}c++$


proc Felab1(in T_cart A[N] output_stream T_cart S[N])
 
inc<"iostream">
$c++{
  int i;
  T_cart B[N];

  for(i=0; i<N; i++) {
    B[i].x = A[i].y;
    B[i].y = -A[i].x;
  }
  assist_out(S, B);
}c++$


proc Felab2(in long A1)
 
inc<"iostream">
$c++{
}c++$