Actual source code: party.c

petsc-master 2019-07-18
Report Typos and Errors

  2:  #include <../src/mat/impls/adj/mpi/mpiadj.h>

  4: #if defined(PETSC_HAVE_UNISTD_H)
  5: #include <unistd.h>
  6: #endif

  8: /*
  9:    Currently using Party-1.99
 10: */
 11: EXTERN_C_BEGIN
 12: #include <party_lib.h>
 13: EXTERN_C_END

 15: typedef struct {
 16:   PetscBool redm;
 17:   PetscBool redo;
 18:   PetscBool recursive;
 19:   PetscBool verbose;
 20:   char      global[15];         /* global method */
 21:   char      local[15];          /* local method */
 22:   PetscInt  nbvtxcoarsed;       /* number of vertices for the coarse graph */
 23: } MatPartitioning_Party;

 25: #define SIZE_LOG 10000          /* size of buffer for mesg_log */

 27: static PetscErrorCode MatPartitioningApply_Party(MatPartitioning part,IS *partitioning)
 28: {
 29:   PetscErrorCode        ierr;
 30:   PetscInt              i,*parttab,*locals,nb_locals,M,N;
 31:   PetscMPIInt           size,rank;
 32:   Mat                   mat = part->adj,matAdj,matSeq,*A;
 33:   Mat_MPIAdj            *adj;
 34:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
 35:   PetscBool             flg;
 36:   IS                    isrow, iscol;
 37:   int                   n,*edge_p,*edge,*vertex_w,p,*part_party,cutsize,redl,rec;
 38:   const char            *redm,*redo;
 39:   char                  *mesg_log;
 40: #if defined(PETSC_HAVE_UNISTD_H)
 41:   int                   fd_stdout,fd_pipe[2],count,err;
 42: #endif

 45:   MPI_Comm_size(PetscObjectComm((PetscObject)mat),&size);
 46:   MPI_Comm_rank(PetscObjectComm((PetscObject)mat),&rank);
 47:   PetscObjectTypeCompare((PetscObject)mat,MATMPIADJ,&flg);
 48:   if (size>1) {
 49:     if (flg) {
 50:       MatMPIAdjToSeq(mat,&matSeq);
 51:      } else {
 52:       PetscInfo(part,"Converting distributed matrix to sequential: this could be a performance loss\n");
 53:       MatGetSize(mat,&M,&N);
 54:       ISCreateStride(PETSC_COMM_SELF,M,0,1,&isrow);
 55:       ISCreateStride(PETSC_COMM_SELF,N,0,1,&iscol);
 56:       MatCreateSubMatrices(mat,1,&isrow,&iscol,MAT_INITIAL_MATRIX,&A);
 57:       ISDestroy(&isrow);
 58:       ISDestroy(&iscol);
 59:       matSeq = *A;
 60:       PetscFree(A);
 61:      }
 62:   } else {
 63:     PetscObjectReference((PetscObject)mat);
 64:     matSeq = mat;
 65:   }

 67:   if (!flg) { /* convert regular matrix to MPIADJ */
 68:     MatConvert(matSeq,MATMPIADJ,MAT_INITIAL_MATRIX,&matAdj);
 69:   } else {
 70:     PetscObjectReference((PetscObject)matSeq);
 71:     matAdj = matSeq;
 72:   }

 74:   adj = (Mat_MPIAdj*)matAdj->data;  /* finaly adj contains adjacency graph */

 76:   /* arguments for Party library */
 77:   n        = mat->rmap->N;             /* number of vertices in full graph */
 78:   edge_p   = adj->i;                   /* start of edge list for each vertex */
 79:   edge     = adj->j;                   /* edge list data */
 80:   vertex_w = part->vertex_weights;     /* weights for all vertices */
 81:   p        = part->n;                  /* number of parts to create */
 82:   redl     = party->nbvtxcoarsed;      /* how many vertices to coarsen down to? */
 83:   rec      = party->recursive ? 1 : 0; /* recursive bisection */
 84:   redm     = party->redm ? "lam" : ""; /* matching method */
 85:   redo     = party->redo ? "w3" : "";  /* matching optimization method */

 87:   PetscMalloc1(mat->rmap->N,&part_party);

 89:   /* redirect output to buffer */
 90: #if defined(PETSC_HAVE_UNISTD_H)
 91:   fd_stdout = dup(1);
 92:   if (pipe(fd_pipe)) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"Could not open pipe");
 93:   close(1);
 94:   dup2(fd_pipe[1],1);
 95:   PetscMalloc1(SIZE_LOG,&mesg_log);
 96: #endif

 98:   /* library call */
 99:   party_lib_times_start();
100:   party_lib(n,vertex_w,NULL,NULL,NULL,edge_p,edge,NULL,p,part_party,&cutsize,redl,(char*)redm,(char*)redo,party->global,party->local,rec,1);

102:   party_lib_times_output(1);
103:   part_info(n,vertex_w,edge_p,edge,NULL,p,part_party,1);

105: #if defined(PETSC_HAVE_UNISTD_H)
106:   err = fflush(stdout);
107:   if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on stdout");
108:   count = read(fd_pipe[0],mesg_log,(SIZE_LOG-1)*sizeof(char));
109:   if (count<0) count = 0;
110:   mesg_log[count] = 0;
111:   close(1);
112:   dup2(fd_stdout,1);
113:   close(fd_stdout);
114:   close(fd_pipe[0]);
115:   close(fd_pipe[1]);
116:   if (party->verbose) {
117:     PetscPrintf(PetscObjectComm((PetscObject)mat),mesg_log);
118:   }
119:   PetscFree(mesg_log);
120: #endif
121:   if (ierr) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"Party failed");

123:   PetscMalloc1(mat->rmap->N,&parttab);
124:   for (i=0; i<mat->rmap->N; i++) parttab[i] = part_party[i];

126:   /* creation of the index set */
127:   nb_locals = mat->rmap->n;
128:   locals    = parttab + mat->rmap->rstart;

130:   ISCreateGeneral(PetscObjectComm((PetscObject)part),nb_locals,locals,PETSC_COPY_VALUES,partitioning);

132:   /* clean up */
133:   PetscFree(parttab);
134:   PetscFree(part_party);
135:   MatDestroy(&matSeq);
136:   MatDestroy(&matAdj);
137:   return(0);
138: }

140: PetscErrorCode MatPartitioningView_Party(MatPartitioning part,PetscViewer viewer)
141: {
142:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
143:   PetscErrorCode        ierr;
144:   PetscBool             isascii;

147:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
148:   if (isascii) {
149:     PetscViewerASCIIPrintf(viewer,"  Global method: %s\n",party->global);
150:     PetscViewerASCIIPrintf(viewer,"  Local method: %s\n",party->local);
151:     PetscViewerASCIIPrintf(viewer,"  Number of vertices for the coarse graph: %d\n",party->nbvtxcoarsed);
152:     if (party->redm) {
153:       PetscViewerASCIIPrintf(viewer,"  Using matching method for graph reduction\n");
154:     }
155:     if (party->redo) {
156:       PetscViewerASCIIPrintf(viewer,"  Using matching optimization\n");
157:     }
158:     if (party->recursive) {
159:       PetscViewerASCIIPrintf(viewer,"  Using recursive bipartitioning\n");
160:     }
161:   }
162:   return(0);
163: }

165: /*@C
166:    MatPartitioningPartySetGlobal - Set global method for Party partitioner.

168:    Collective on MatPartitioning

170:    Input Parameters:
171: +  part - the partitioning context
172: -  method - a string representing the method

174:    Options Database:
175: .  -mat_partitioning_party_global <method> - the global method

177:    Level: advanced

179:    Notes:
180:    The method may be one of MP_PARTY_OPT, MP_PARTY_LIN, MP_PARTY_SCA,
181:    MP_PARTY_RAN, MP_PARTY_GBF, MP_PARTY_GCF, MP_PARTY_BUB or MP_PARTY_DEF, or
182:    alternatively a string describing the method. Two or more methods can be
183:    combined like "gbf,gcf". Check the Party Library Users Manual for details.

185: .seealso: MatPartitioningPartySetLocal()
186: @*/
187: PetscErrorCode MatPartitioningPartySetGlobal(MatPartitioning part,const char *global)
188: {

193:   PetscTryMethod(part,"MatPartitioningPartySetGlobal_C",(MatPartitioning,const char*),(part,global));
194:   return(0);
195: }

197: PetscErrorCode MatPartitioningPartySetGlobal_Party(MatPartitioning part,const char *global)
198: {
199:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
200:   PetscErrorCode        ierr;

203:   PetscStrncpy(party->global,global,15);
204:   return(0);
205: }

207: /*@C
208:    MatPartitioningPartySetLocal - Set local method for Party partitioner.

210:    Collective on MatPartitioning

212:    Input Parameters:
213: +  part - the partitioning context
214: -  method - a string representing the method

216:    Options Database:
217: .  -mat_partitioning_party_local <method> - the local method

219:    Level: advanced

221:    Notes:
222:    The method may be one of MP_PARTY_HELPFUL_SETS, MP_PARTY_KERNIGHAN_LIN, or
223:    MP_PARTY_NONE. Check the Party Library Users Manual for details.

225: .seealso: MatPartitioningPartySetGlobal()
226: @*/
227: PetscErrorCode MatPartitioningPartySetLocal(MatPartitioning part,const char *local)
228: {

233:   PetscTryMethod(part,"MatPartitioningPartySetLocal_C",(MatPartitioning,const char*),(part,local));
234:   return(0);
235: }

237: PetscErrorCode MatPartitioningPartySetLocal_Party(MatPartitioning part,const char *local)

239: {
240:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
241:   PetscErrorCode        ierr;

244:   PetscStrncpy(party->local,local,15);
245:   return(0);
246: }

248: /*@
249:    MatPartitioningPartySetCoarseLevel - Set the coarse level parameter for the
250:    Party partitioner.

252:    Collective on MatPartitioning

254:    Input Parameters:
255: +  part - the partitioning context
256: -  level - the coarse level in range [0.0,1.0]

258:    Options Database:
259: .  -mat_partitioning_party_coarse <l> - Coarse level

261:    Level: advanced
262: @*/
263: PetscErrorCode MatPartitioningPartySetCoarseLevel(MatPartitioning part,PetscReal level)
264: {

270:   PetscTryMethod(part,"MatPartitioningPartySetCoarseLevel_C",(MatPartitioning,PetscReal),(part,level));
271:   return(0);
272: }

274: PetscErrorCode MatPartitioningPartySetCoarseLevel_Party(MatPartitioning part,PetscReal level)
275: {
276:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;

279:   if (level<0.0 || level>1.0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Party: level of coarsening out of range [0.0-1.0]");
280:   party->nbvtxcoarsed = (PetscInt)(part->adj->cmap->N * level);
281:   if (party->nbvtxcoarsed < 20) party->nbvtxcoarsed = 20;
282:   return(0);
283: }

285: /*@
286:    MatPartitioningPartySetMatchOptimization - Activate matching optimization for
287:    graph reduction.

289:    Collective on MatPartitioning

291:    Input Parameters:
292: +  part - the partitioning context
293: -  opt - boolean flag

295:    Options Database:
296: .  -mat_partitioning_party_match_optimization - Matching optimization on/off

298:    Level: advanced
299: @*/
300: PetscErrorCode MatPartitioningPartySetMatchOptimization(MatPartitioning part,PetscBool opt)
301: {

307:   PetscTryMethod(part,"MatPartitioningPartySetMatchOptimization_C",(MatPartitioning,PetscBool),(part,opt));
308:   return(0);
309: }

311: PetscErrorCode MatPartitioningPartySetMatchOptimization_Party(MatPartitioning part,PetscBool opt)
312: {
313:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;

316:   party->redo = opt;
317:   return(0);
318: }

320: /*@
321:    MatPartitioningPartySetBipart - Activate or deactivate recursive bisection.

323:    Collective on MatPartitioning

325:    Input Parameters:
326: +  part - the partitioning context
327: -  bp - boolean flag

329:    Options Database:
330: -  -mat_partitioning_party_bipart - Bipartitioning option on/off

332:    Level: advanced
333: @*/
334: PetscErrorCode MatPartitioningPartySetBipart(MatPartitioning part,PetscBool bp)
335: {

341:   PetscTryMethod(part,"MatPartitioningPartySetBipart_C",(MatPartitioning,PetscBool),(part,bp));
342:   return(0);
343: }

345: PetscErrorCode MatPartitioningPartySetBipart_Party(MatPartitioning part,PetscBool bp)
346: {
347:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;

350:   party->recursive = bp;
351:   return(0);
352: }

354: PetscErrorCode MatPartitioningSetFromOptions_Party(PetscOptionItems *PetscOptionsObject,MatPartitioning part)
355: {
356:   PetscErrorCode        ierr;
357:   PetscBool             flag;
358:   char                  value[256];
359:   PetscReal             r;
360:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;

363:   PetscOptionsHead(PetscOptionsObject,"Set Party partitioning options");
364:   PetscOptionsString("-mat_partitioning_party_global","Global method","MatPartitioningPartySetGlobal",party->global,value,256,&flag);
365:   if (flag) { MatPartitioningPartySetGlobal(part,value); }
366:   PetscOptionsString("-mat_partitioning_party_local","Local method","MatPartitioningPartySetLocal",party->local,value,256,&flag);
367:   if (flag) { MatPartitioningPartySetLocal(part,value); }
368:   PetscOptionsReal("-mat_partitioning_party_coarse","Coarse level","MatPartitioningPartySetCoarseLevel",0.0,&r,&flag);
369:   if (flag) { MatPartitioningPartySetCoarseLevel(part,r); }
370:   PetscOptionsBool("-mat_partitioning_party_match_optimization","Matching optimization on/off","MatPartitioningPartySetMatchOptimization",party->redo,&party->redo,NULL);
371:   PetscOptionsBool("-mat_partitioning_party_bipart","Bipartitioning on/off","MatPartitioningPartySetBipart",party->recursive,&party->recursive,NULL);
372:   PetscOptionsBool("-mat_partitioning_party_verbose","Show library output","",party->verbose,&party->verbose,NULL);
373:   PetscOptionsTail();
374:   return(0);
375: }

377: PetscErrorCode MatPartitioningDestroy_Party(MatPartitioning part)
378: {
379:   MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
380:   PetscErrorCode        ierr;

383:   PetscFree(party);
384:   /* clear composed functions */
385:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetGlobal_C",NULL);
386:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetLocal_C",NULL);
387:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetCoarseLevel_C",NULL);
388:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetMatchOptimization_C",NULL);
389:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetBipart_C",NULL);
390:   return(0);
391: }

393: /*MC
394:    MATPARTITIONINGPARTY - Creates a partitioning context via the external package Party.

396:    Level: beginner

398:    Notes:
399:     See http://wwwcs.upb.de/fachbereich/AG/monien/RESEARCH/PART/party.html

401: .seealso: MatPartitioningSetType(), MatPartitioningType

403: M*/

405: PETSC_EXTERN PetscErrorCode MatPartitioningCreate_Party(MatPartitioning part)
406: {
407:   PetscErrorCode        ierr;
408:   MatPartitioning_Party *party;

411:   PetscNewLog(part,&party);
412:   part->data = (void*)party;

414:   PetscStrcpy(party->global,"gcf,gbf");
415:   PetscStrcpy(party->local,"kl");

417:   party->redm         = PETSC_TRUE;
418:   party->redo         = PETSC_TRUE;
419:   party->recursive    = PETSC_TRUE;
420:   party->verbose      = PETSC_FALSE;
421:   party->nbvtxcoarsed = 200;

423:   part->ops->apply          = MatPartitioningApply_Party;
424:   part->ops->view           = MatPartitioningView_Party;
425:   part->ops->destroy        = MatPartitioningDestroy_Party;
426:   part->ops->setfromoptions = MatPartitioningSetFromOptions_Party;

428:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetGlobal_C",MatPartitioningPartySetGlobal_Party);
429:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetLocal_C",MatPartitioningPartySetLocal_Party);
430:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetCoarseLevel_C",MatPartitioningPartySetCoarseLevel_Party);
431:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetMatchOptimization_C",MatPartitioningPartySetMatchOptimization_Party);
432:   PetscObjectComposeFunction((PetscObject)part,"MatPartitioningPartySetBipart_C",MatPartitioningPartySetBipart_Party);
433:   return(0);
434: }