/[escript]/trunk/dudley/src/Mesh_optimizeDOFDistribution.c
ViewVC logotype

Diff of /trunk/dudley/src/Mesh_optimizeDOFDistribution.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

temp_trunk_copy/finley/src/Mesh_optimizeDOFDistribution.c revision 1384 by phornby, Fri Jan 11 02:29:38 2008 UTC trunk/finley/src/Mesh_optimizeDOFDistribution.c revision 1763 by gross, Mon Sep 8 02:47:55 2008 UTC
# Line 26  Line 26 
26  #ifdef _OPENMP  #ifdef _OPENMP
27  #include <omp.h>  #include <omp.h>
28  #endif  #endif
29    #ifdef USE_PARMETIS
30    #include "parmetis.h"
31    #endif
32    
33  /**************************************************************/  /**************************************************************/
34    
# Line 40  void Finley_Mesh_optimizeDOFDistribution Line 43  void Finley_Mesh_optimizeDOFDistribution
43       Paso_MPI_rank myRank,dest,source,current_rank, rank;       Paso_MPI_rank myRank,dest,source,current_rank, rank;
44       Finley_IndexList* index_list=NULL;       Finley_IndexList* index_list=NULL;
45       float *xyz=NULL;       float *xyz=NULL;
46         int c;
47            
48       #ifdef PASO_MPI       #ifdef PASO_MPI
49       MPI_Status status;       MPI_Status status;
# Line 67  void Finley_Mesh_optimizeDOFDistribution Line 71  void Finley_Mesh_optimizeDOFDistribution
71       newGlobalDOFID=TMPMEMALLOC(len,index_t);       newGlobalDOFID=TMPMEMALLOC(len,index_t);
72       setNewDOFId=TMPMEMALLOC(in->Nodes->numNodes,bool_t);       setNewDOFId=TMPMEMALLOC(in->Nodes->numNodes,bool_t);
73       if (!(Finley_checkPtr(partition) || Finley_checkPtr(xyz) || Finley_checkPtr(partition_count) || Finley_checkPtr(partition_count) || Finley_checkPtr(newGlobalDOFID) || Finley_checkPtr(setNewDOFId))) {       if (!(Finley_checkPtr(partition) || Finley_checkPtr(xyz) || Finley_checkPtr(partition_count) || Finley_checkPtr(partition_count) || Finley_checkPtr(newGlobalDOFID) || Finley_checkPtr(setNewDOFId))) {
74             dim_t *recvbuf=TMPMEMALLOC(mpiSize*mpiSize,dim_t);
75    
76           /* set the coordinates: *?           /* set the coordinates: */
77           /* it is assumed that at least one node on this processor provides a coordinate */           /* it is assumed that at least one node on this processor provides a coordinate */
78           #pragma omp parallel for private(i,j,k)           #pragma omp parallel for private(i,j,k)
79           for (i=0;i<in->Nodes->numNodes;++i) {           for (i=0;i<in->Nodes->numNodes;++i) {
# Line 91  void Finley_Mesh_optimizeDOFDistribution Line 96  void Finley_Mesh_optimizeDOFDistribution
96                }                }
97            /* ksteube build CSR format */            /* ksteube build CSR format */
98                /*  insert contributions from element matrices into colums index index_list: */                /*  insert contributions from element matrices into colums index index_list: */
99                Finley_IndexList_insertElementsWithRowRange(index_list, myFirstVertex, myLastVertex,                Finley_IndexList_insertElementsWithRowRangeNoMainDiagonal(index_list, myFirstVertex, myLastVertex,
100                                                            in->Elements,in->Nodes->globalDegreesOfFreedom,                                                                          in->Elements,in->Nodes->globalDegreesOfFreedom,
101                                                            in->Nodes->globalDegreesOfFreedom);                                                                          in->Nodes->globalDegreesOfFreedom);
102                Finley_IndexList_insertElementsWithRowRange(index_list, myFirstVertex, myLastVertex,                Finley_IndexList_insertElementsWithRowRangeNoMainDiagonal(index_list, myFirstVertex, myLastVertex,
103                                                            in->FaceElements,in->Nodes->globalDegreesOfFreedom,                                                                          in->FaceElements,in->Nodes->globalDegreesOfFreedom,
104                                                            in->Nodes->globalDegreesOfFreedom);                                                                          in->Nodes->globalDegreesOfFreedom);
105                Finley_IndexList_insertElementsWithRowRange(index_list, myFirstVertex, myLastVertex,                Finley_IndexList_insertElementsWithRowRangeNoMainDiagonal(index_list, myFirstVertex, myLastVertex,
106                                                            in->ContactElements,in->Nodes->globalDegreesOfFreedom,                                                                          in->ContactElements,in->Nodes->globalDegreesOfFreedom,
107                                                            in->Nodes->globalDegreesOfFreedom);                                                                          in->Nodes->globalDegreesOfFreedom);
108                Finley_IndexList_insertElementsWithRowRange(index_list, myFirstVertex, myLastVertex,                Finley_IndexList_insertElementsWithRowRangeNoMainDiagonal(index_list, myFirstVertex, myLastVertex,
109                                                            in->Points,in->Nodes->globalDegreesOfFreedom,                                                                          in->Points,in->Nodes->globalDegreesOfFreedom,
110                                                            in->Nodes->globalDegreesOfFreedom);                                                                          in->Nodes->globalDegreesOfFreedom);
111             }             }
112                        
113             /* create the local matrix pattern */             /* create the local matrix pattern */
114             pattern=Finley_IndexList_createPattern(myNumVertices,index_list,0,globalNumVertices,0);             pattern=Finley_IndexList_createPattern(0,myNumVertices,index_list,0,globalNumVertices,0);
115    
116             /* clean up index list */             /* clean up index list */
117             if (index_list!=NULL) {             if (index_list!=NULL) {
# Line 116  void Finley_Mesh_optimizeDOFDistribution Line 121  void Finley_Mesh_optimizeDOFDistribution
121    
122             if (Finley_noError()) {             if (Finley_noError()) {
123    
124    #ifdef USE_PARMETIS
125    
126              if (in->MPIInfo->size>1) {
127             int i;
128             int wgtflag = 0;
129             int numflag = 0;   /* pattern->ptr is C style: starting from 0 instead of 1 */
130             int ncon = 1;
131             int edgecut;
132             int options[2];
133             float *tpwgts = TMPMEMALLOC(ncon*mpiSize,float);
134             float *ubvec = TMPMEMALLOC(ncon,float);
135             for (i=0; i<ncon*mpiSize; i++) tpwgts[i] = 1.0/(float)mpiSize;
136             for (i=0; i<ncon; i++) ubvec[i] = 1.05;
137             options[0] = 3;
138             options[1] = 15;
139    
140    {
141    int k=distribution[in->MPIInfo->rank+1]-distribution[in->MPIInfo->rank];
142    int min_i,max_i;
143    printf("INPUT PARMETIS: %d\n",k);
144    for(i=0;i<in->MPIInfo->size+1;++i) printf("%d ",distribution[i]);
145    printf("\n");
146    min_i=pattern->index[0];
147    max_i=pattern->index[0];
148    for(i=0;i<pattern->ptr[k];++i) {
149    min_i=MIN(min_i,pattern->index[i]);
150    max_i=MAX(max_i,pattern->index[i]);
151    }
152    printf("index range = %d : %d\n",min_i,max_i);
153    
154    for(i=0;i<k+1;++i) printf("%d ",pattern->ptr[i]);
155    printf("\n");
156  /*  /*
157    for(i=0;i<pattern->ptr[k];++i) printf("%d ",pattern->index[i]);
158    printf("\n");
159    */
160    }
161    
162          ParMETIS_V3_PartGeomKway(distribution,           ParMETIS_V3_PartGeomKway(distribution,
163                                   pattern->ptr,                                   pattern->ptr,
164                                   pattern->index,                                   pattern->index,
165                                   idxtype *vwgt, +                                   NULL,
166                                   idxtype *adjwgt, +                                   NULL,
167                                   int *wgtflag, +                                   &wgtflag,
168                                   int *numflag, +                                   &numflag,
169                                   dim,                                   &dim,
170                                   xyz,                                   xyz,
171                                   int *ncon, +                                   &ncon,
172                                   mpiSize,                                   &mpiSize,
173                                   float *tpwgts, +                                   tpwgts,
174                                   float *ubvec, +                                   ubvec,
175                                   int *options, +                                   options,
176                                   int *edgecut, +                                   &edgecut,
177                                   partition,                                   partition,             /* new CPU ownership of elements */
178                                   in->MPIInfo->comm);                                   &(in->MPIInfo->comm));
179  */           printf("ParMETIS number of edges cut by partitioning per processor: %d\n", edgecut/MAX(in->MPIInfo->size,1));
180                 for (i=0;i<myNumVertices;++i) partition[i]=myRank; /* remove */                   TMPMEMFREE(ubvec);
181                     TMPMEMFREE(tpwgts);
182              } else {
183                     for (i=0;i<myNumVertices;++i) partition[i]=0;      /* CPU 0 owns it */
184              }
185    #else
186                  for (i=0;i<myNumVertices;++i) partition[i]=myRank;    /* CPU 0 owns it */
187    #endif
188    
189             }             }
190    
191             Paso_Pattern_free(pattern);             Paso_Pattern_free(pattern);
# Line 156  void Finley_Mesh_optimizeDOFDistribution Line 205  void Finley_Mesh_optimizeDOFDistribution
205                 THREAD_MEMFREE(loc_partition_count);                 THREAD_MEMFREE(loc_partition_count);
206             }             }
207             #ifdef PASO_MPI             #ifdef PASO_MPI
208                MPI_Allreduce( new_distribution, partition_count, mpiSize, MPI_INT, MPI_SUM, in->MPIInfo->comm );            /* recvbuf will be the concatenation of each CPU's contribution to new_distribution */
209              MPI_Allgather(new_distribution, mpiSize, MPI_INT, recvbuf, mpiSize, MPI_INT, in->MPIInfo->comm);
210             #else             #else
211                 for (i=0;i<mpiSize;++i) partition_count[i]=new_distribution[i];                 for (i=0;i<mpiSize;++i) recvbuf[i]=new_distribution[i];
212             #endif             #endif
213             new_distribution[0]=0;             new_distribution[0]=0;
214             for (i=0;i<mpiSize;++i) {         for (rank=0; rank<mpiSize;rank++) {
215                 new_distribution[i+1]=new_distribution[i]+partition_count[i];            c=0;
216                 partition_count[i]=0;                for (i=0;i<myRank;++i) c+=recvbuf[rank+mpiSize*i];
217             }                for (i=0;i<myNumVertices;++i) {
218             for (i=0;i<myNumVertices;++i) {                   if (rank==partition[i]) {
219                rank=partition[i];                      newGlobalDOFID[i]=new_distribution[rank]+c;
220                newGlobalDOFID[i]=new_distribution[rank]+partition_count[rank];                      c++;
221                partition_count[rank]++;               }
222                  }
223                  for (i=myRank+1;i<mpiSize;++i) c+=recvbuf[rank+mpiSize*i];
224                  new_distribution[rank+1]=new_distribution[rank]+c;
225             }             }
226               TMPMEMFREE(recvbuf);
227    
228             /* now the overlap needs to be created by sending the partition around*/             /* now the overlap needs to be created by sending the partition around*/
229    
230             dest=Paso_MPIInfo_mod(mpiSize, myRank + 1);             dest=Paso_MPIInfo_mod(mpiSize, myRank + 1);
# Line 203  void Finley_Mesh_optimizeDOFDistribution Line 258  void Finley_Mesh_optimizeDOFDistribution
258                }                }
259             }             }
260             for (i=0;i<mpiSize+1;++i) distribution[i]=new_distribution[i];             for (i=0;i<mpiSize+1;++i) distribution[i]=new_distribution[i];
   
             
261           }           }
262           TMPMEMFREE(index_list);           TMPMEMFREE(index_list);
263       }       }

Legend:
Removed from v.1384  
changed lines
  Added in v.1763

  ViewVC Help
Powered by ViewVC 1.1.26