Changeset 14709 for issm/trunk-jpl/src/c/classes/objects/Bucket.h

Timestamp:

04/22/13 18:03:21 (12 years ago)

Author:

Eric.Larour

Message:

CHG: finished Assemble routine using non-synchronous I/O.

File:

• issm/trunk-jpl/src/c/classes/objects/Bucket.h (modified) (3 diffs)

issm/trunk-jpl/src/c/classes/objects/Bucket.h

@@ -10 +10 @@
 #include "./Object.h"
 #include "../../shared/Alloc/alloc.h"
+#include "../../Container/DataSet.h"
+#include "../../toolkits/toolkitsenums.h"
 /*}}}*/
+
+#define BUCKETSIZEOFREQUESTS 6 /*how many MPI_Isend requests does it take to transfer the contents of a bucket to another cpu?*/
 
 template <class doubletype> class Bucket: public Object{
@@ -25 +29 @@
         
                 /*constructors, destructors: */
+                Bucket(){ /*{{{*/
+                        this->m=0;
+                        this->n=0;
+                        this->idxm=NULL;
+                        this->idxn=NULL;
+                        this->values=NULL;
+                        mode=INS_VAL;
+                } /*}}}*/
                 Bucket(int min,int* idxmin,int nin,int* idxnin,doubletype* valuesin,InsMode modein){ /*{{{*/
                         this->m=min;
@@ -79 +91 @@
                         _error_("Not implemented yet (similar to Elements)"); };
                 /*}}}*/
+                
+                /*specific routines of Bucket: */
+                void SpawnBucketsPerCpu(DataSet* bucketsofcpu_i,int rank_i,int* rowranks){ /*{{{*/
+
+                        int i,j;
+
+                        /*go through our idxm index of rows this bucket owns, and spawn buckets  
+                         *if these rows belong to cpu rank_i. Use rowranks to determine this.*/
+                        for(i=0;i<m;i++){
+                                if (rowranks[idxm[i]]==rank_i){
+                                        /*This row belongs to cpu rank_i, so spawn a bucket with this row, and add it to the bucketsofcpu_i dataset: */
+                                        bucketsofcpu_i->AddObject(new Bucket(1,idxm+i,n,idxn,values+n*i,mode));
+                                }
+                        }
+
+                };
+                /*}}}*/
+                void SetLocalMatrixValues(double* local_matrix,int lower_row,int global_N){ /*{{{*/
+
+                        int i,j;
+                        for(i=0;i<m;i++){
+                                for(j=0;j<n;j++){
+                                        *(local_matrix+global_N*(idxm[i]-lower_row)+idxn[j])=*(values+n*i+j);
+                                }
+                        }
+                        
+                };
+                /*}}}*/
+                void Isend(int receiver_rank,MPI_Request* requests,int* pcount,MPI_Comm comm){ /*{{{*/
+                        int count=0;
+                        int int_mode;
+
+                        /*Recover pointer: */
+                        count=*pcount;
+
+                        /*Send all the information required: */
+                        MPI_Isend(&m,1,MPI_INT,receiver_rank,2,comm,requests+count); count++;
+                        if(m){ MPI_Isend(idxm,m,MPI_INT,receiver_rank,3,comm,requests+count); count++; }
+                        MPI_Isend(&n,1,MPI_INT,receiver_rank,4,comm,requests+count); count++;
+                        if(n){ MPI_Isend(idxn,n,MPI_INT,receiver_rank,5,comm,requests+count); count++; }
+                        if(m*n){ MPI_Isend(values,m*n,MPI_DOUBLE,receiver_rank,6,comm,requests+count); count++; }
+                        int_mode=(int)mode;
+                        MPI_Isend(&int_mode,1,MPI_INT,receiver_rank,7,comm,requests+count); count++;
+
+                        /*Allocate pointers: */
+                        *pcount=count;
+
+                } /*}}}*/
+                void Recv(int sender_rank, MPI_Comm comm){ /*{{{*/
+
+                        MPI_Status status;
+                        int int_mode;
+
+                        MPI_Recv(&m,1, MPI_INT,sender_rank,2, comm, &status);
+                        if(m){
+                                idxm=new int[m];
+                                MPI_Recv(idxm,m, MPI_INT,sender_rank,3, comm, &status);
+                        }
+                        MPI_Recv(&n,1, MPI_INT,sender_rank,4, comm, &status);
+                        if(n){
+                                idxn=new int[n];
+                                MPI_Recv(idxn,n, MPI_INT,sender_rank,5, comm, &status);
+                        }
+                        if(m*n){
+                                values=new doubletype[m*n];
+                                MPI_Recv(values,m*n, MPI_DOUBLE,sender_rank,6, comm, &status);
+                        }
+                        MPI_Recv(&int_mode,1, MPI_INT,sender_rank,7, comm, &status);
+                        mode=(InsMode)int_mode;
+
+                } /*}}}*/
 };