// -*- C++ -*-
#define N 10
#define N_PV 2
#define R (N/N_PV)

#define matrice_ris "/tmp/matrice_ris"

generic main()
{
  /* N e' la dimensione della matrice 
     N_PV e' il numero dei PV utlizzati 
     R e' il numero di righe assegnate ad ogni PV 
     matrice_A e matrice_B sono i file che contengono le due matrici (A, B) da moltiplicare 
     matrice_ris e' il file che contiene la matrice risultato della moltiplicazione (C) */
  stream ref_t A_rif;
  stream ref_t[2] B_C_rif;
  stream ref_t C2_rif;

  genera_A          (output_stream A_rif);
  genera_B_alloca_C (output_stream B_C_rif);
  moltiplicazione   (input_stream A_rif, B_C_rif  output_stream C2_rif);
  end               (input_stream C2_rif);
} 

 
genera_A(output_stream ref_t A_rif) {
  proc_genera_A(output_stream A_rif);
}


proc proc_genera_A(output_stream ref_t A_rif)
inc<"fstream","iostream">
$c++{ 
  int displ;
  int dim_matrice = N*N*sizeof(long);
  int dim_riga = N*sizeof(long);

  long riga_A[N];
  ref_t ref_matrice;

  // messaggio di partenza x il regression test
  std::cerr << "STARTING generaA" << std::endl;
  
  /* allocazione della matrice A in memoria condivisa */ 
  REF_New (&ref_matrice, dim_matrice, REF_Default, 0);

  for (int i=0; i<N; i++) {
    /* lettura da file della riga i-esima */
    for(int j=0; j<N; j++) riga_A[j] = i;
      
    /* scrittura in memoria condivisa della riga i-esima */
    displ = i*N*sizeof(long);
    REF_D_Write (&ref_matrice, riga_A, displ, dim_riga); 
  }
  
  assist_out (A_rif, ref_matrice);
}c++$

 
genera_B_alloca_C(output_stream ref_t B_C_rif[2]) {
  proc_genera_B_alloca_C(output_stream B_C_rif); 
}


proc proc_genera_B_alloca_C(output_stream ref_t B_C_rif[2])
inc<"fstream","iostream">
$c++{ 
  int displ;
  int dim_matrice = N*N*sizeof(long);
  int dim_col = N*sizeof(long);

  long B[N][N];
  long col_B[N];

  ref_t ref_matrici[2];

  //std::ifstream f;
    
  // messaggio di partenza x il regression test
  std::cerr << "STARTING generaB" << std::endl;
  
  /* allocazione della matrice B e della matrice C in memoria condivisa */ 
  REF_New (&(ref_matrici[0]), dim_matrice, REF_Default, 0);
  REF_New (&(ref_matrici[1]), dim_matrice, REF_Default, 0);

  /* lettura da file della matrice B */
  //f.open (matrice_B);
  for (int i=0; i<N; i++)
    for(int j=0; j<N; j++)
      B[i][j] = j;
  //f.close();

  /* la matrice B viene memorizzata per colonne nell'area di memoria condivisa */
  for(int j=0; j<N; j++) {
    for (int i=0; i<N; i++) 
      col_B[i] = B[i][j];
    
    /* scrittura in memoria condivisa della colonna j-esima */
    displ = j*N*sizeof(long);
    REF_D_Write (&(ref_matrici[0]), col_B, displ, dim_col); 
  }
  
  assist_out (B_C_rif, ref_matrici);
}c++$


parmod moltiplicazione(input_stream ref_t A_rif, ref_t B_C_rif[2]  output_stream ref_t C2_rif) {
  
  topology array [i:N_PV] Pv;
  stream ref_t C_rif;
  
  do input_section {
    guard1: on , , A_rif && B_C_rif {
      distribution A_rif broadcast to Pv;
      distribution B_C_rif broadcast to Pv;
    }
  } while (true)
  
  virtual_processors {
    molt (in guard1 out C_rif) {
      VP i {
	proc_molt (in A_rif, B_C_rif, i out C_rif);
      }
    }
  }
 
  output_section {
    collects C_rif from ALL Pv[i] {
      ref_t el;
      ref_t ris;
      AST_FOR_EACH(el) {
	ris = el;
      }
      assist_out (C2_rif, ris);
    }<>;
  }
}


proc proc_molt(in ref_t A_rif, ref_t B_C_rif[2], long i out ref_t C_rif)
inc<"iostream">
$c++{
  int displ;
  int dim_matrice_PV = (N*N*sizeof(long))/N_PV;
  int dim_riga = N*sizeof(long);
  int base = i*R*N*sizeof(long);

  long righe_PV_i[R][N];
  long col[N];
  long ris[R][N];


  /* lettura della riga i-esima della matrice A */
  displ = base;
  cerr << "LETTURA i= "<< i << " displ = " << displ << " size = " <<  dim_matrice_PV << endl;
  REF_D_Read (&(A_rif), righe_PV_i, displ, dim_matrice_PV);
 
  for (int k=0; k<N; k++) {
    /* lettura della colonna k-esima di B */
    displ = k*N*sizeof(long); 
    REF_D_Read (&(B_C_rif[0]), &(col), displ, dim_riga);
      
    for (int h=0; h<R; h++) {
      /* moltiplicazione della riga h-esima di righe_PV_i 
	 per la colonna k-esima di B 
	 e memorizzazione del risultato in ris[h][k] */
      ris[h][k] = 0;
      for (int ind=0; ind<N; ind++)
	ris[h][k] += (righe_PV_i[h][ind]*col[ind]);
    }
  }

  /* memorizzazione del risultato nella matrice C (riga per riga) */
  for(int k=0; k<R; k++) {
    displ = base + k*N*sizeof(long);
    std::cerr <<" VP " << i << " memorizzo nel displ = " << displ << std::endl; 
    REF_D_Write (&(B_C_rif[1]), ris[k], displ, dim_riga);
  }
  
  C_rif = B_C_rif[1];  
}c++$


/* stampa su file e a video della matrice risultato */
end(input_stream ref_t C2_rif)
 
inc<"fstream", "iostream">
$c++{
  int displ;
  int size = N*sizeof(long);
  long riga_C[N];
  std::ofstream f;

  // verifica del risultato tramite esecuzione sequenziale della moltiplicazione
  static long A[N][N];
  static long B[N][N];
  static long C[N][N];
  int ok = 0;
  
  // lettura da file della matrice A 
  for (int i=0; i<N; i++) 
    for(int j=0; j<N; j++) 
      A[i][j] = i;
  
  // lettura da file della matrice B 
  for (int i=0; i<N; i++)
    for(int j=0; j<N; j++)
      B[i][j] = j;

  /* calcolo e stampa di C */
  for (int i=0; i<N; i++) 
    for (int j=0; j<N; j++) {
      C[i][j] = 0;
      for (int k=0; k<N; k++) 
	C[i][j] += A[i][k]*B[k][j];
    }
  
  /* scrittura del risultato sulla matrice di output e controllo del risultato */
  f.open (matrice_ris);
  for(int i=0; i<N; i++) {
    /* lettura della riga i-esima dalla memoria condivisa */
    displ = i*N*sizeof(long);
    REF_D_Read (&(C2_rif), riga_C, displ, size); 
    
    /* memorizzazione su file della riga i-esima */
    for(int j=0; j<N; j++) {
      f << riga_C[j] << " " ;
      
      // verifica del risultato
      if (C[i][j] != riga_C[j]) {
	ok = -1;
	std::cerr << "Errore: ricevuto C[" << i << "][" << j << "] = " << riga_C[j] << std::endl;
	std::cerr << "        calcolato " << C[i][j] << std::endl;
      }
    }
    f << std::endl;
    
  }
  f.close();
  
  // messaggio di terminazione x il regression test
  if (ok==0) 
    std::cerr << "ENDING with SUCCESS molt_ref_k.ast" << std::endl;
  else 
    std::cerr << "ENDING with FAILURE molt_ref_k.ast" << std::endl;
  REF_Delete (&C2_rif); 
}c++$