From: mquinson <mquinson@48e7efb5-ca39-0410-a469-dd3cf9ba447f>
Date: Tue, 13 Jun 2006 08:59:37 +0000 (+0000)
Subject: More work on this. Looks better now, but still doesn't run properly
X-Git-Tag: v3.3~2982
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/33eeb4be26b53ed1561488ce78e392b40ecf74df

More work on this. Looks better now, but still doesn't run properly


git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@2376 48e7efb5-ca39-0410-a469-dd3cf9ba447f
---

diff --git a/examples/gras/pmm/pmm.c b/examples/gras/pmm/pmm.c
index bed221ba75..8dc7235fb6 100755
--- a/examples/gras/pmm/pmm.c
+++ b/examples/gras/pmm/pmm.c
@@ -1,31 +1,28 @@
 /* $Id$ */
 /* pmm - parallel matrix multiplication "double diffusion"                  */
 
-/* Copyright (c) 2006- Ahmed Harbaoui. All rights reserved.                 */
+/* Copyright (c) 2006 Ahmed Harbaoui.                                       */
+/* Copyright (c) 2006 Martin Quinson.                                       */
+/* All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "gras.h"
-#define PROC_MATRIX_SIZE 3
+#include "xbt/matrix.h"
+#define PROC_MATRIX_SIZE 2
 #define SLAVE_COUNT (PROC_MATRIX_SIZE*PROC_MATRIX_SIZE)
 
-#define DATA_MATRIX_SIZE 3
+#define DATA_MATRIX_SIZE 4
+const int submatrix_size = DATA_MATRIX_SIZE/PROC_MATRIX_SIZE;
 
 XBT_LOG_NEW_DEFAULT_CATEGORY(pmm,"Parallel Matrix Multiplication");
 
-GRAS_DEFINE_TYPE(s_matrix,struct s_matrix {
-  int lines;
-  int rows;
-  double *data GRAS_ANNOTE(size, lines*rows);
-};)
-typedef struct s_matrix matrix_t;
-
 /* struct for recovering results */
 GRAS_DEFINE_TYPE(s_result,struct s_result {
-  int i;
-  int j;
-  double value;
+  int linepos;
+  int rowpos;
+  xbt_matrix_t C GRAS_ANNOTE(subtype,double);
 });
 typedef struct s_result result_t;
 
@@ -35,15 +32,16 @@ GRAS_DEFINE_TYPE(s_assignment,struct s_assignment {
   int rowpos;
   xbt_host_t line[PROC_MATRIX_SIZE];
   xbt_host_t row[PROC_MATRIX_SIZE];
-  double a;
-  double b;
+  xbt_matrix_t A GRAS_ANNOTE(subtype,double);
+  xbt_matrix_t B GRAS_ANNOTE(subtype,double);
 });
-typedef struct s_assignment assignment_t;
+typedef struct s_assignment s_assignment_t;
 
 /* register messages which may be sent (common to client and server) */
 static void register_messages(void) {
   gras_datadesc_type_t result_type;
   gras_datadesc_type_t assignment_type;
+
   gras_datadesc_set_const("PROC_MATRIX_SIZE",PROC_MATRIX_SIZE);
   result_type=gras_datadesc_by_symbol(s_result);
   assignment_type=gras_datadesc_by_symbol(s_assignment);
@@ -85,15 +83,6 @@ typedef struct {
 } master_data_t;
 
 
-/***  Function initilaze matrixs ***/
-
-static void initmatrix(matrix_t *X){
-  int i;
-
-  for(i=0 ; i<(X->lines)*(X->rows); i++)
-    X->data[i]=1.0;//*rand()/(RAND_MAX+1.0);
-} /* end_of_initmatrixs */
-
 /***  Function Scatter Sequentiel ***/
 
 static void scatter(){
@@ -118,41 +107,13 @@ static void gather(){
 
 }/* end_of_gather */
 
-/***  Function: Display Matrix ***/
-
-static void display(matrix_t X){
-	
-  int i,j,t=0;
-
-  printf("      ");
-  for(j=0;j<X.rows;j++)
-    printf("%.3d ",j);
-  printf("\n");
-  printf("    __");
-  for(j=0;j<X.rows;j++)
-    printf("____");
-  printf("_\n");
-
-  for(i=0;i<X.lines;i++){
-    printf("%.3d | ",i);
-    for(j=0;j<X.rows;j++)
-      printf("%.3g ",X.data[t++]);
-    printf("|\n");
-  }
-  printf("    --");
-  for(j=0;j<X.rows;j++)
-    printf("----");
-  printf("-\n");
-
-}/* end_of_display */
-
 int master (int argc,char *argv[]) {
 
   xbt_ex_t e;
 
   int i,port,ask_result,step;
 
-  matrix_t A,B,C;
+  xbt_matrix_t A,B,C;
   result_t result;
 
   gras_socket_t from;
@@ -163,19 +124,15 @@ int master (int argc,char *argv[]) {
   xbt_host_t grid[SLAVE_COUNT]; /* The slaves */
   gras_socket_t socket[SLAVE_COUNT]; /* sockets for brodcast to slaves */
 
-  /*  Initialize Matrixs */
+  /*  Initialize Matrices */
 
-  A.lines=A.rows=DATA_MATRIX_SIZE;
-  B.lines=B.rows=DATA_MATRIX_SIZE;
-  C.lines=C.rows=DATA_MATRIX_SIZE;
-	
-  A.data=xbt_malloc0(sizeof(double)*DATA_MATRIX_SIZE*DATA_MATRIX_SIZE);
-  B.data=xbt_malloc0(sizeof(double)*DATA_MATRIX_SIZE*DATA_MATRIX_SIZE);
-  C.data=xbt_malloc0(sizeof(double)*DATA_MATRIX_SIZE*DATA_MATRIX_SIZE);
-	
-  initmatrix(&A);
-  initmatrix(&B);
+  A = xbt_matrix_double_new_id(DATA_MATRIX_SIZE,DATA_MATRIX_SIZE);
+  B = xbt_matrix_double_new_seq(DATA_MATRIX_SIZE,DATA_MATRIX_SIZE);
+  C = xbt_matrix_double_new_zeros(DATA_MATRIX_SIZE,DATA_MATRIX_SIZE);
 	
+  //xbt_matrix_dump(B,"B:seq",0,xbt_matrix_dump_display_double);
+
+
   /*  Get arguments and create sockets */
   port=atoi(argv[1]);
   //scatter();
@@ -187,37 +144,43 @@ int master (int argc,char *argv[]) {
   int step_ack;
   gras_os_sleep(5);
 
-  for( i=1;i< argc;i++){
+  for( i=1;i<argc && i<=SLAVE_COUNT;i++){
     grid[i-1]=xbt_host_from_string(argv[i]);
     socket[i-1]=gras_socket_client(grid[i-1]->name,grid[i-1]->port);
       
     INFO2("Connected to %s:%d.",grid[i-1]->name,grid[i-1]->port);
   }
+  /* FIXME: let the surnumerous slave die properly */
 
-  int row=1, line=1;
+  int row=0, line=0;
   for(i=0 ; i<SLAVE_COUNT; i++){
-    assignment_t assignment;
+    s_assignment_t assignment;
     int j;
 
-    assignment.linepos=line;  // My line
-    assignment.rowpos=row;  // My row
-
+    assignment.linepos=line; // assigned line
+    assignment.rowpos=row;   // assigned row
 
     /* Neiborhood */
     for (j=0; j<PROC_MATRIX_SIZE; j++) {
-      assignment.row[j] = grid[ j*PROC_MATRIX_SIZE+(row-1) ] ;
-      assignment.line[j] =  grid[ (line-1)*PROC_MATRIX_SIZE+j ] ;
+      assignment.row[j] = grid[ j*PROC_MATRIX_SIZE+(row) ] ;
+      assignment.line[j] =  grid[ (line)*PROC_MATRIX_SIZE+j ] ;
     }
 
+    assignment.A=xbt_matrix_new_sub(A,
+				    submatrix_size,submatrix_size,
+				    submatrix_size*line,submatrix_size*row,
+				    NULL);
+    assignment.B=xbt_matrix_new_sub(B,
+				    submatrix_size,submatrix_size,
+				    submatrix_size*line,submatrix_size*row,
+				    NULL);
+    //xbt_matrix_dump(assignment.B,"assignment.B",0,xbt_matrix_dump_display_double);
     row++;
-    if (row > PROC_MATRIX_SIZE) {
-      row=1;
+    if (row >= PROC_MATRIX_SIZE) {
+      row=0;
       line++;
     }
 		
-    assignment.a=A.data[(line-1)*PROC_MATRIX_SIZE+(row-1)];
-    assignment.b=B.data[(line-1)*PROC_MATRIX_SIZE+(row-1)];;
-		
     gras_msg_send(socket[i],gras_msgtype_by_name("assignment"),&assignment);
     //    INFO3("Send assignment to %s : data A= %.3g & data B= %.3g",
     //	  gras_socket_peer_name(socket[i]),mydata.a,mydata.b);
@@ -228,7 +191,7 @@ int master (int argc,char *argv[]) {
   /******************************* multiplication ********************************/
   INFO0("XXXXXXXXXXXXXXXXXXXXXX begin Multiplication");
 	
-  for (step=1; step <= PROC_MATRIX_SIZE; step++){
+  for (step=0; step < PROC_MATRIX_SIZE; step++){
     for (i=0; i< SLAVE_COUNT; i++){
       TRY {
 	gras_msg_send(socket[i], gras_msgtype_by_name("step"), &step);
@@ -237,7 +200,7 @@ int master (int argc,char *argv[]) {
 	RETHROW0("Unable to send the msg : %s");
       }
     }
-    INFO1("send to slave to begin a %d th step",step);
+    INFO1("XXXXXX Next step (%d)",step);
 
     /* wait for computing and slave messages exchange */
 
@@ -263,11 +226,14 @@ int master (int argc,char *argv[]) {
   /* wait for results */
   for( i=1;i< argc;i++){
     gras_msg_wait(600,gras_msgtype_by_name("result"),&from,&result);
-    C.data[(result.i-1)*DATA_MATRIX_SIZE+(result.j-1)]=result.value;
+    xbt_matrix_copy_values(result.C,C,   submatrix_size,submatrix_size,
+			   submatrix_size*result.linepos,
+			   submatrix_size*result.rowpos,
+			   0,0,NULL);
   }
   /*    end of gather   */
   INFO0 ("The Result of Multiplication is :");
-  display(C);
+  xbt_matrix_dump(C,"C:res",0,xbt_matrix_dump_display_double);
 
   return 0;
 } /* end_of_master */
@@ -281,11 +247,14 @@ int slave(int argc,char *argv[]) {
   xbt_ex_t e; 
 
   int step,port,l,result_ack=0; 
-  double bA,bB;
+  xbt_matrix_t bA=xbt_matrix_new(submatrix_size,submatrix_size,
+				 sizeof(double),NULL);
+  xbt_matrix_t bB=xbt_matrix_new(submatrix_size,submatrix_size,
+				 sizeof(double),NULL);
 
   int myline,myrow;
-  double mydataA,mydataB;
-  double bC=0;
+  xbt_matrix_t mydataA,mydataB;
+  xbt_matrix_t bC=xbt_matrix_double_new_zeros(submatrix_size,submatrix_size);
   
   result_t result;
  
@@ -312,7 +281,7 @@ int slave(int argc,char *argv[]) {
   register_messages();
 
   /* Recover my initialized Data and My Position*/
-  assignment_t assignment;
+  s_assignment_t assignment;
   INFO2("Launch %s (port=%d); wait for my enrole message",argv[0],port);
   TRY {
     gras_msg_wait(600,gras_msgtype_by_name("assignment"),&master,&assignment);
@@ -321,19 +290,21 @@ int slave(int argc,char *argv[]) {
   }
   myline  = assignment.linepos;
   myrow   = assignment.rowpos;
-  mydataA = assignment.a;
-  mydataB = assignment.b;
-  INFO4("Receive my pos (%d,%d) and assignment ( A=%.3g | B=%.3g )",
-	myline,myrow,mydataA,mydataB);
+  mydataA = assignment.A;
+  mydataB = assignment.B;
+  INFO1("mydataB=%p",mydataB);
+
+  INFO2("Receive my pos (%d,%d) and assignment",myline,myrow);
 
-  /* Get my neighborhood from the assignment message */
+  //  xbt_matrix_dump(mydataB,"myB",0,xbt_matrix_dump_display_double);
+
+  /* Get my neighborhood from the assignment message (skipping myself) */
   int j=0;
   for (i=0,j=0 ; i<PROC_MATRIX_SIZE ; i++){
     if (strcmp(gras_os_myname(),assignment.line[i]->name)) {
       socket_line[j]=gras_socket_client(assignment.line[i]->name,
 					assignment.line[i]->port);
       j++;
-      //INFO3("Line neighbour %d: %s:%d",j,mydata.line[i]->name,mydata.line[i]->port);
     }
     xbt_host_free(assignment.line[i]);
   }
@@ -341,16 +312,13 @@ int slave(int argc,char *argv[]) {
     if (strcmp(gras_os_myname(),assignment.row[i]->name)) {
       socket_row[j]=gras_socket_client(assignment.row[i]->name,
 				       assignment.row[i]->port);
-      //INFO3("Row neighbour %d : %s:%d",j,mydata.row[i]->name,mydata.row[i]->port);
       j++;
     }
     xbt_host_free(assignment.row[i]);    
   }
 
-  step=1;
   
   do {  //repeat until compute Cb
-    step=PROC_MATRIX_SIZE+1;  // just intilization for loop
 	
     TRY {
       gras_msg_wait(200,gras_msgtype_by_name("step"),NULL,&step);
@@ -359,60 +327,77 @@ int slave(int argc,char *argv[]) {
     }
     INFO1("Receive a step message from master: step = %d ",step);
 
-    if (step < PROC_MATRIX_SIZE ){
-      /* a line brodcast */
-      gras_os_sleep(3);  // IL FAUT EXPRIMER LE TEMPS D'ATTENTE EN FONCTION DE "SLAVE_COUNT"
-      if(myline==step){
-	INFO2("step(%d) = Myline(%d)",step,myline);
-	for (l=1;l < PROC_MATRIX_SIZE ;l++){
-	  gras_msg_send(socket_row[l-1], gras_msgtype_by_name("dataB"), &mydataB);
-	  bB=mydataB;
-	  INFO1("send my data B (%.3g) to my (vertical) neighbors",bB);  
-	}
-      }
-      if(myline != step){ 
-	INFO2("step(%d) <> Myline(%d)",step,myline);
-	TRY {
-	  gras_msg_wait(600,gras_msgtype_by_name("dataB"),&from,&bB);
-	} CATCH(e) {
-	  RETHROW0("Can't get a data message from line : %s");
-	}
-	INFO2("Receive data B (%.3g) from my neighbor: %s",bB,gras_socket_peer_name(from));
-      }
-      /* a row brodcast */
-      if(myrow==step){
-	for (l=1;l < PROC_MATRIX_SIZE ;l++){
-	  gras_msg_send(socket_line[l-1],gras_msgtype_by_name("dataA"), &mydataA);
-	  bA=mydataA;
-	  INFO1("send my data A (%.3g) to my (horizontal) neighbors",bA);
-	}
+    /* a line brodcast */
+    gras_os_sleep(3);  // IL FAUT EXPRIMER LE TEMPS D'ATTENTE EN FONCTION DE "SLAVE_COUNT"
+
+    if(myline==step){
+      INFO2("step(%d) = Myline(%d)",step,myline);
+      for (l=0;l < PROC_MATRIX_SIZE-1 ;l++){
+	INFO1("mydataB=%p",mydataB);
+	gras_msg_send(socket_row[l], 
+		      gras_msgtype_by_name("dataB"), 
+		      &mydataB);
+	INFO1("mydataB=%p",mydataB);
+	
+	xbt_matrix_free(bB);
+	INFO1("mydataB=%p",mydataB);
+	xbt_matrix_dump(mydataB,"myB",0,xbt_matrix_dump_display_double);
+	bB = xbt_matrix_new_sub(mydataB,
+				submatrix_size,submatrix_size,
+				0,0,NULL);
+	
+	INFO0("send my data B to my (vertical) neighbors");
       }
-
-      if(myrow != step){
-	TRY {
-	  gras_msg_wait(1200,gras_msgtype_by_name("dataA"), &from,&bA);
-	} CATCH(e) {
-	  RETHROW0("Can't get a data message from row : %s");
-	}
-	INFO2("Receive data A (%.3g) from my neighbor : %s ",bA,gras_socket_peer_name(from));
+    } else {
+      INFO2("step(%d) <> Myline(%d)",step,myline);
+      TRY {
+	INFO1("mydataB=%p",mydataB);
+	xbt_matrix_free(bB);
+	INFO1("mydataB=%p",mydataB);
+	gras_msg_wait(600,gras_msgtype_by_name("dataB"),&from,&bB);
+	INFO1("mydataB=%p",mydataB);
+      } CATCH(e) {
+	RETHROW0("Can't get a data message from line : %s");
       }
-      bC+=bA*bB;
-      INFO1(">>>>>>>> My BC = %.3g",bC);
+      INFO1("Receive data B from my neighbor: %s",
+	    gras_socket_peer_name(from));
+    }
 
-      /* send a ack msg to master */
+    /* a row brodcast */
+    if (myrow==step) {
+      for (l=1;l < PROC_MATRIX_SIZE ;l++){
+	gras_msg_send(socket_line[l-1],gras_msgtype_by_name("dataA"), &mydataA);
+	xbt_matrix_free(bA);
+	bA = xbt_matrix_new_sub(mydataA,
+				submatrix_size,submatrix_size,
+				0,0,NULL);
 	
-      gras_msg_send(master,gras_msgtype_by_name("step_ack"),&step);
-	
-      INFO1("Send ack to master for to end %d th step",step);
+	INFO0("send my data A to my (horizontal) neighbors");
+      }
+    } else {
+      TRY {
+	xbt_matrix_free(bA);
+	gras_msg_wait(1200,gras_msgtype_by_name("dataA"), &from,&bA);
+      } CATCH(e) {
+	RETHROW0("Can't get a data message from row : %s");
+      }
+      INFO1("Receive data A from my neighbor : %s ",
+	    gras_socket_peer_name(from));
     }
-    if(step==PROC_MATRIX_SIZE-1) break;
+    xbt_matrix_double_addmult(bA,bB,bC);
+
+    /* send a ack msg to master */
 	
+    gras_msg_send(master,gras_msgtype_by_name("step_ack"),&step);
+    
+    INFO1("Send ack to master for to end %d th step",step);
+  	
   } while (step < PROC_MATRIX_SIZE);
   /*  wait Message from master to send the result */
  
-  result.value=bC;
-  result.i=myline;
-  result.j=myrow;
+  result.C=bC;
+  result.linepos=myline;
+  result.rowpos=myrow;
  
   TRY {
     gras_msg_wait(600,gras_msgtype_by_name("ask_result"),
@@ -427,8 +412,7 @@ int slave(int argc,char *argv[]) {
     // gras_socket_close(from);
     RETHROW0("Failed to send PING to server: %s");
   }
-  INFO3(">>>>>>>> Result: %.3f sent to %s:%d <<<<<<<<",
-	bC,
+  INFO2(">>>>>>>> Result sent to %s:%d <<<<<<<<",
 	gras_socket_peer_name(master),gras_socket_peer_port(master));
   /*  Free the allocated resources, and shut GRAS down */
   gras_socket_close(master);