DidaWiki

Strumenti Utente

Strumenti Sito

Ti trovi qui: DidaWiki » Master (Laurea Magistrale) in Computer Science and Networking » Strumenti di programmazione per sistemi paralleli e distribuiti » Examples of ASSIST code
magistraleinformaticanetworking:spd:assistexamples

Differenze

Queste sono le differenze tra la revisione selezionata e la versione attuale della pagina.

Link a questa pagina di confronto

Entrambe le parti precedenti la revisioneRevisione precedente
Prossima revisione		Revisione precedente
magistraleinformaticanetworking:spd:assistexamples [19/05/2010 alle 12:41 (16 anni fa)] – Massimo Coppolamagistraleinformaticanetworking:spd:assistexamples [19/05/2010 alle 12:52 (16 anni fa)] (versione attuale) – Massimo Coppola
Linea 525: Linea 525:
 }c$ }c$
 </file> </file>
- 
 ====More complex examples of parmod usage==== ====More complex examples of parmod usage====
 +===parmod.ast===
 +<file - parmod.ast>
 +// -*- C++ -*-
 +#define N 10
 +#define M 5
 +
 +generic main()
 +{
 +  stream long A1;
 +  stream long B1;
 +
 +  genera(output_stream A1);  
 +  p_array(input_stream A1 output_stream B1);
 +  fine1(input_stream B1);
 +}
 +
 +
 +genera(output_stream long A1) {
 +  fgen(output_stream A1);
 +}
 +
 +
 +proc fgen(output_stream long A1)
 +inc<"iostream">
 +$c++{
 +  long a;
 +  
 +  // start regression test
 +  std::cerr << "STARTING gen" << std::endl;
 +
 +  for (int i=0;i<N;i++) {
 +    a = i;
 +    assist_out(A1, a);
 +  };
 +}c++$
 +
 +
 +parmod p_array (input_stream long A1 output_stream long B1) {
 +  topology array[i:M] Pv;
 +  attribute long z;
 +
 +  do input_section {
 +    guard1: on , , A1 {
 +      distribution A1 broadcast to Pv;
 +      operation {
 + z = z + 1;
 +      }<use {z}>
 +    }
 +  } while (true)
 +  
 +  virtual_processors {
 +    elab1 (in guard1 out B1) {
 +      VP i {
 + f_p1 (in A1 output_stream B1);
 +      }
 +    }
 +  }
 +   
 +  output_section {
 +    collects B1 from ANY Pv;
 +  } 
 +}
 +
 +
 +fine1(input_stream long B1)
 + 
 +inc<"iostream">
 +$c++{
 +  static int count = 0;
 +  static int ok = 0;
 +
 +  //std::cerr << "Fine -> ricevuto B1 = " << B1 <<std::endl;
 +  
 +  // verify result
 +  long b;
 +
 +  if (B1 != ((int)(count/M))) ok = -1;
 +  count++;
 +
 +  // end of regression test
 +  if (count >= N*M) {  
 +    if (ok==0) 
 +      std::cerr << "ENDING with SUCCESS fine parmod.ast" << std::endl;
 +    else std::cerr << "ENDING with FAILURE fine parmod.ast" << std::endl;
 +  }
 +}c++$
 +
 +
 +proc f_p1(in long A1 output_stream long B1)
 + 
 +inc<"iostream">
 +$c++{
 +  long b = A1;
 +  assist_out(B1,b);
 +}c++$
 +</file>
 +===parmod_due_proc.ast===
 +<file - parmod_due_proc.ast>
 +// -*- C++ -*-
 + 
 +#define   CIPATH "/usr/include"
 +
 +#define    N 10
 +#define    M 5
 +#define NUM1 0
 +#define NUM2 1
 +
 +generic main()
 +{
 +  stream long    A;
 +  stream long[2] B;
 +
 +  genera   (                 output_stream A);  
 +  p_array  (input_stream A   output_stream B);
 +  fine1    (input_stream B);
 +}
 +
 +
 +genera(output_stream long A) {
 +  fgen(output_stream A);
 +}
 +
 +
 +proc fgen(output_stream long A)
 + 
 +inc<"iostream">
 +$c++{
 +  long a;
 +  
 +  // start of regression test
 +  std::cerr << "STARTING gen" << std::endl;
 +
 +  for (int i=0;i<N;i++) {
 +    a = i;
 +    assist_out(A, a);
 +  };
 +}c++$
 +
 +
 +parmod p_array (input_stream long A output_stream long B[2]) {
 +  
 +  topology array[i:M] Pv;
 +  attribute long b[2] replicated;
 +
 +  do input_section {
 +    guard1: on , , A {
 +      distribution A broadcast to Pv;
 +    }
 +  } while (true)
 +  
 +  virtual_processors {
 +    elab1 (in guard1) {
 +      VP i {
 + f_p1 (in A, i  out b);
 +        f_p2 (in b  out b);
 + assist_out (B, b);
 +      }
 +    }
 +  }
 +   
 +  output_section {
 +    collects B from ANY Pv;
 +  } 
 +}
 +
 +
 +fine1(input_stream long B[2])
 + 
 +inc<"iostream">
 +$c++{
 +  static int count = 0;
 +  static int ok = 0;
 +
 +  long b;
 +  
 +  if (B[1] != NUM2) ok = -1;
 +  count++;
 +  
 +  // end of regression test
 +  if (count >= N*M) {  
 +    if (ok==0) 
 +      std::cerr << "ENDING with SUCCESS fine parmod_due_proc.ast" << std::endl;
 +    else std::cerr << "ENDING with FAILURE fine parmod_due_proc.ast" << std::endl;
 +  }
 +}c++$
 +
 +
 +proc f_p1(in long A, long i  out long B[2])
 + 
 +inc<"iostream">
 +$c++{
 +  B[0] = i;
 +  B[1] = NUM1;
 +}c++$
 +
 +
 +proc f_p2(in long B1[2]  out long B2[2])
 + 
 +inc<"iostream">
 +$c++{
 +  B2[0] = B1[0];
 +  B2[1] = NUM2;
 +}c++$
 +</file>
 +===nondeterminismo.ast===
 +<file - nondeterminismo.ast>
 +// -*- C++ -*-
 +
 +/* ------------------------------------------------------------ */
 +/* This example test nondeterministic receive over two streams  */
 +/* in a parmod with none topology                               */
 +/* Program graph contains 2 sequential modules, a parmod and    */
 +/* a further sequential.                                        */
 +/* ------------------------------------------------------------ */
 +
 + 
 + 
 +
 +#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];
 +  
 +  // start 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;
 +  
 +  // start 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;
 +
 +  // verift result
 +  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();
 +    
 +    // end of 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++$
 +</file>
 +===array_scatter.ast===
 +<file - array_scatter.ast>
 +// -*- C++ -*-
 +#define N 10
 +
 +generic main()
 +{
 +  stream long[N] A1;
 +  stream long[N] A2;
 +  stream long[N] B1;
 +  stream long[N] B2;
 +  
 +  genera1  (output_stream A1);
 +  genera2  (output_stream A2);  
 +  cross    (input_stream A1, A2  output_stream B1, B2);
 +  fine1    (input_stream B1);
 +  fine2    (input_stream B2);
 +}
 +
 +
 +genera1(output_stream long A1[N]) {
 +  fgen1(output_stream A1);
 +}
 +
 +
 +proc fgen1(output_stream long A1[N])
 +inc<"iostream">
 +$c++{
 +  long a[N];
 +  
 +  // start regression test
 +  std::cerr << "STARTING fgen1" << std::endl;
 +
 +  for (int i=0;i<N;i++) 
 +    a[i] = i;
 +  
 +  assist_out(A1, a);
 +}c++$
 +
 +
 +genera2(output_stream long A2[N]) {
 +  fgen2(output_stream A2);
 +}
 +
 +
 +proc fgen2(output_stream long A2[N])
 +inc<"iostream">
 +$c++{
 +  long a[N];
 +
 +  // start regression test
 +  std::cerr << "STARTING fgen2" << std::endl;
 +
 +  for (int i=0;i<N;i++)
 +    a[i] = 10 + i;
 +  
 +  assist_out(A2,a);
 +}c++$
 +
 +
 +parmod cross(input_stream long A1[N], long A2[N]  output_stream long B1[N], long B2[N]) {
 +
 +  topology array [i:N] Pv;
 +
 +  attribute long S[N] scatter S[*i0] onto Pv[i0];
 +
 +  stream long s1;
 +  stream long s2;
 +
 +  do input_section {
 +    guard1: on , , A1 {
 +      distribution A1[*j] scatter to S[j];
 +    }
 +    guard2: on , , A2 {
 +      distribution A2[*k] scatter to S[k];
 +    }  
 +  } while (true)
 +  
 +  virtual_processors {
 +    elab1(in guard1 out s1) {
 +      VP i {
 + f_p1(in S[i] out s1);
 +      }
 +    }
 +    elab2(in guard2 out s2) {
 +      VP i {
 + f_p2(in S[i] out s2);
 +      }
 +    }
 +  }
 +  
 +  output_section {
 +    collects s1 from ALL Pv[i] {  
 +      int el1;
 +      int B1_[N];
 +      AST_FOR_EACH(el1) {
 + B1_[i]=el1;
 +      }
 +      assist_out (B1, B1_);
 +    }<>;
 +
 +    collects s2 from ALL Pv[i] {
 +      int el2;
 +      int B2_[N];
 +      AST_FOR_EACH(el2) {
 + B2_[i]=el2;
 +      }
 +      assist_out (B2, B2_);
 +    }<>;
 +  } 
 +}
 +
 +
 +fine1(input_stream long B1[N])
 + 
 +inc<"iostream">
 +$c++{
 +  int ok = 0;
 +  
 +  /*
 +    std::cerr << "Fine1: " << std::endl;
 +    for (int i=0; i<N; i++)
 +    std::cerr << B1[i] << " ";
 +    std::cerr << std::endl;
 +  */
 +  
 +  for (int i=0;i<N;i++) if (B1[i] != i) ok = -1;
 +  if (ok==0) 
 +    std::cerr << "ENDING with SUCCESS fine1 array_scatter.ast" << std::endl;
 +  else  
 +    std::cerr << "ENDING with FAILURE fine1 array_scatter.ast" << std::endl;
 +}c++$
 +
 +
 +fine2(input_stream long B2[N])
 + 
 +inc<"iostream">
 +$c++{
 +  int ok = 0;
 +
 +  /*
 +    std::cerr << "Fine2: " << std::endl;
 +    for (int i=0; i<N; i++)
 +    std::cerr << B2[i] << " ";
 +    std::cerr << std::endl;
 +  */
 +
 +  for (int i=0;i<N;i++) if (B2[i] != (10 + i)) ok = -1;
 +  if (ok==0) 
 +    std::cerr << "ENDING with SUCCESS fine2 array_scatter.ast" << std::endl;
 +  else  
 +    std::cerr << "ENDING with FAILURE fine2 array_scatter.ast" << std::endl;
 +}c++$
 +
 +
 +proc f_p1(in long A1 out long B1)
 + 
 +inc<"iostream">
 +$c++{
 +  long b;
 +  b = A1;
 +  B1 = b;
 +}c++$
 +
 +
 +proc f_p2(in long A2 out long B2)
 + 
 +inc<"iostream">
 +$c++{
 +  B2 = A2;
 +}c++$
 +</file>
 +===array_on_demand_attrib_array_replic.ast===
 +<file - array_on_demand_attrib_array_replic.ast>
 +// -*- C++ -*-
 +#define N 5
 +#define M 10
 +#define MAX_ITER 20
 +#define RIS "/tmp/risultato.txt"
 +
 +/***************************************************************/
 +/*                                                             */
 +/* Test of the on_demand distribution over the array topology  */
 +/*                                                             */
 +/* The parmod "elabora" has array topology                     */
 +/*                                                             */
 +/* The replicated attribute is a one-dimension array           */
 +/*                                                             */
 +/**************************************************************/
 +
 +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];
 +
 +  // start 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 in module builder solved:
 +     it was taking B_ as an integer, while it is an 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);
 +  }
 +
 +  /* print and verify results */
 +  for (int i=0; i<M; i++) {
 +    f << B[i] << std::endl;
 +    if (B[i] != i) ok = -1;
 +  }
 +  count++;
 +  
 +  // end of 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++$
 +</file>
 +
magistraleinformaticanetworking/spd/assistexamples.1274272872.txt.gz · Ultima modifica: 19/05/2010 alle 12:41 (16 anni fa) da Massimo Coppola
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki