int
SCOTCH_graphMapCompute (
SCOTCH_Graph * const grafptr, /*+ Graph to order +*/
SCOTCH_Mapping * const mappptr, /*+ Mapping to compute +*/
SCOTCH_Strat * const stratptr) /*+ Mapping strategy +*/
{
Kgraph mapgrafdat; /* Effective mapping graph */
const Strat * mapstratptr; /* Pointer to mapping strategy */
LibMapping * restrict lmapptr;
int o;
#ifdef SCOTCH_DEBUG_GRAPH2
if (graphCheck ((Graph *) grafptr) != 0) {
errorPrint ("SCOTCH_graphMapCompute: invalid input graph");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
lmapptr = (LibMapping *) mappptr;
if (*((Strat **) stratptr) == NULL) { /* Set default mapping strategy if necessary */
ArchDom archdomnorg;
archDomFrst (&lmapptr->m.archdat, &archdomnorg);
if (archVar (&lmapptr->m.archdat))
SCOTCH_stratGraphClusterBuild (stratptr, 0, 1, 0.0, 0.05);
else
SCOTCH_stratGraphMapBuild (stratptr, 0, archDomSize (&lmapptr->m.archdat, &archdomnorg), 0.05);
}
mapstratptr = *((Strat **) stratptr);
if (mapstratptr->tabl != &kgraphmapststratab) {
errorPrint ("SCOTCH_graphMapCompute: not a graph mapping strategy");
return (1);
}
if (kgraphInit (&mapgrafdat, (Graph *) grafptr, &lmapptr->m) != 0)
return (1);
o = kgraphMapSt (&mapgrafdat, mapstratptr); /* Perform mapping */
lmapptr->m.domnmax = mapgrafdat.m.domnmax; /* Do not free the mapping, as it has been cloned */
lmapptr->m.domnnbr = mapgrafdat.m.domnnbr;
lmapptr->m.domntab = mapgrafdat.m.domntab; /* Update pointer to domntab in case it has changed */
mapgrafdat.m.parttax = NULL; /* Prevent mapping arrays from being freed by graph */
mapgrafdat.m.domntab = NULL;
kgraphExit (&mapgrafdat);
if (lmapptr->parttax != NULL) { /* Propagate mapping data to user partition array */
Gnum vertnum;
Gnum vertnnd;
for (vertnum = lmapptr->m.baseval, vertnnd = vertnum + lmapptr->m.vertnbr;
vertnum < vertnnd; vertnum ++)
lmapptr->parttax[vertnum] = archDomNum (&lmapptr->m.archdat, &lmapptr->m.domntab[lmapptr->m.parttax[vertnum]]);
}
return (o);
}
void ScotchRefineLB::work(LDStats *stats) {
/** ========================== INITIALIZATION ============================= */
ProcArray *parr = new ProcArray(stats);
ObjGraph *ogr = new ObjGraph(stats);
int cost_array[10] = {64, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536};
/** ============================= STRATEGY ================================ */
// convert ObjGraph to the Scotch graph
SCOTCH_Num baseval = 0; // starting index of vertices
SCOTCH_Num vertnbr = ogr->vertices.size(); // number of vertices
SCOTCH_Num edgenbr = 0; // number of edges
SCOTCH_Num *oldpemap = (SCOTCH_Num *)malloc(sizeof(SCOTCH_Num) * vertnbr);
double maxLoad = 0.0;
double minLoad = 0.0;
if (vertnbr > 0) {
minLoad = ogr->vertices[baseval].getVertexLoad();
}
long maxBytes = 1;
int i, j, k, vert;
/** remove duplicate edges from recvFrom */
for(i = baseval; i < vertnbr; i++) {
for(j = 0; j < ogr->vertices[i].sendToList.size(); j++) {
vert = ogr->vertices[i].sendToList[j].getNeighborId();
for(k = 0; k < ogr->vertices[i].recvFromList.size(); k++) {
if(ogr->vertices[i].recvFromList[k].getNeighborId() == vert) {
ogr->vertices[i].sendToList[j].setNumBytes(ogr->vertices[i].sendToList[j].getNumBytes() + ogr->vertices[i].recvFromList[k].getNumBytes());
ogr->vertices[i].recvFromList.erase(ogr->vertices[i].recvFromList.begin() + k);
}
}
}
}
/** the object load is normalized to an integer between 0 and 256 */
for(i = baseval; i < vertnbr; i++) {
if(ogr->vertices[i].getVertexLoad() > maxLoad)
maxLoad = ogr->vertices[i].getVertexLoad();
if (ogr->vertices[i].getVertexLoad() < minLoad) {
minLoad = ogr->vertices[i].getVertexLoad();
}
edgenbr += ogr->vertices[i].sendToList.size() + ogr->vertices[i].recvFromList.size();
oldpemap[i] = ogr->vertices[i].getCurrentPe();
}
for(i = baseval; i < vertnbr; i++) {
for(j = 0; j < ogr->vertices[i].sendToList.size(); j++) {
if (ogr->vertices[i].sendToList[j].getNumBytes() > maxBytes) {
maxBytes = ogr->vertices[i].sendToList[j].getNumBytes();
}
}
for(j = 0; j < ogr->vertices[i].recvFromList.size(); j++) {
if (ogr->vertices[i].recvFromList[j].getNumBytes() > maxBytes) {
maxBytes = ogr->vertices[i].recvFromList[j].getNumBytes();
}
}
}
/* adjacency list */
SCOTCH_Num *verttab = (SCOTCH_Num *)malloc(sizeof(SCOTCH_Num) * (vertnbr+1));
/* loads of vertices */
SCOTCH_Num *velotab = (SCOTCH_Num *)malloc(sizeof(SCOTCH_Num) * vertnbr);
/* id of the neighbors */
SCOTCH_Num *edgetab = (SCOTCH_Num *)malloc(sizeof(SCOTCH_Num) * edgenbr);
/* number of bytes exchanged */
SCOTCH_Num *edlotab = (SCOTCH_Num *)malloc(sizeof(SCOTCH_Num) * edgenbr);
int edgeNum = 0;
double ratio = 256.0/maxLoad;
double byteRatio = 1024.0/maxBytes;
for(i = baseval; i < vertnbr; i++) {
verttab[i] = edgeNum;
velotab[i] = (int)ceil(ogr->vertices[i].getVertexLoad() * ratio);
for(j = 0; j < ogr->vertices[i].sendToList.size(); j++) {
edgetab[edgeNum] = ogr->vertices[i].sendToList[j].getNeighborId();
edlotab[edgeNum] = (int) ceil(ogr->vertices[i].sendToList[j].getNumBytes()
* byteRatio);
edgeNum++;
}
for(j = 0; j < ogr->vertices[i].recvFromList.size(); j++) {
edgetab[edgeNum] = ogr->vertices[i].recvFromList[j].getNeighborId();
edlotab[edgeNum] = (int)
ceil(ogr->vertices[i].recvFromList[j].getNumBytes() * byteRatio);
edgeNum++;
}
}
verttab[i] = edgeNum;
CkAssert(edgeNum == edgenbr);
SCOTCH_Graph graph; // Graph to partition
SCOTCH_Strat strat; // Strategy to achieve partitioning
/* Initialize data structures */
SCOTCH_graphInit (&graph);
SCOTCH_stratInit (&strat);
SCOTCH_graphBuild (&graph, baseval, vertnbr, verttab, NULL, velotab, NULL, edgenbr, edgetab, edlotab);
SCOTCH_graphCheck (&graph);
double migration_cost = 1024.0;
if (step() == 0) {
SCOTCH_stratGraphMapBuild (&strat, SCOTCH_STRATBALANCE, parr->procs.size (), 0.01);
} else {
SCOTCH_stratGraphMapBuild (&strat, SCOTCH_STRATBALANCE | SCOTCH_STRATREMAP, parr->procs.size (), 0.01);
}
SCOTCH_Num *pemap = (SCOTCH_Num *)malloc(sizeof(SCOTCH_Num) * vertnbr);
// Takes as input the graph, arch graph, strategy, migration cost in
// double, old mapping and new mapping
if (step() == 0) {
SCOTCH_graphPart(&graph, parr->procs.size(), &strat, pemap);
} else {
SCOTCH_graphRepart(&graph, parr->procs.size(), oldpemap, migration_cost, NULL, &strat, pemap);
}
SCOTCH_graphExit (&graph);
SCOTCH_stratExit (&strat);
free(verttab);
free(velotab);
free(edgetab);
free(edlotab);
for(i = baseval; i < vertnbr; i++) {
if(pemap[i] != ogr->vertices[i].getCurrentPe())
ogr->vertices[i].setNewPe(pemap[i]);
}
free(pemap);
free(oldpemap);
/** ============================== CLEANUP ================================ */
ogr->convertDecisions(stats);
delete parr;
delete ogr;
}
static PetscErrorCode MatPartitioningApply_PTScotch_Private(MatPartitioning part, PetscBool useND, IS *partitioning)
{
MPI_Comm pcomm,comm;
MatPartitioning_PTScotch *scotch = (MatPartitioning_PTScotch*)part->data;
PetscErrorCode ierr;
PetscMPIInt rank;
Mat mat = part->adj;
Mat_MPIAdj *adj = (Mat_MPIAdj*)mat->data;
PetscBool flg,distributed;
PetscBool proc_weight_flg;
PetscInt i,j,p,bs=1,nold;
PetscInt *NDorder = NULL;
PetscReal *vwgttab,deltval;
SCOTCH_Num *locals,*velotab,*veloloctab,*edloloctab,vertlocnbr,edgelocnbr,nparts=part->n;
PetscFunctionBegin;
ierr = PetscObjectGetComm((PetscObject)part,&pcomm);CHKERRQ(ierr);
/* Duplicate the communicator to be sure that PTSCOTCH attribute caching does not interfere with PETSc. */
ierr = MPI_Comm_dup(pcomm,&comm);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)mat,MATMPIADJ,&flg);CHKERRQ(ierr);
if (!flg) {
/* bs indicates if the converted matrix is "reduced" from the original and hence the
resulting partition results need to be stretched to match the original matrix */
nold = mat->rmap->n;
ierr = MatConvert(mat,MATMPIADJ,MAT_INITIAL_MATRIX,&mat);CHKERRQ(ierr);
if (mat->rmap->n > 0) bs = nold/mat->rmap->n;
adj = (Mat_MPIAdj*)mat->data;
}
proc_weight_flg = PETSC_TRUE;
ierr = PetscOptionsGetBool(NULL, NULL, "-mat_partitioning_ptscotch_proc_weight", &proc_weight_flg, NULL);CHKERRQ(ierr);
ierr = PetscMalloc1(mat->rmap->n+1,&locals);CHKERRQ(ierr);
if (useND) {
#if defined(PETSC_HAVE_SCOTCH_PARMETIS_V3_NODEND)
PetscInt *sizes, *seps, log2size, subd, *level, base = 0;
PetscMPIInt size;
ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr);
log2size = PetscLog2Real(size);
subd = PetscPowInt(2,log2size);
if (subd != size) SETERRQ(comm,PETSC_ERR_SUP,"Only power of 2 communicator sizes");
ierr = PetscMalloc1(mat->rmap->n,&NDorder);CHKERRQ(ierr);
ierr = PetscMalloc3(2*size,&sizes,4*size,&seps,size,&level);CHKERRQ(ierr);
SCOTCH_ParMETIS_V3_NodeND(mat->rmap->range,adj->i,adj->j,&base,NULL,NDorder,sizes,&comm);
ierr = MatPartitioningSizesToSep_Private(subd,sizes,seps,level);CHKERRQ(ierr);
for (i=0;i<mat->rmap->n;i++) {
PetscInt loc;
ierr = PetscFindInt(NDorder[i],2*subd,seps,&loc);CHKERRQ(ierr);
if (loc < 0) {
loc = -(loc+1);
if (loc%2) { /* part of subdomain */
locals[i] = loc/2;
} else {
ierr = PetscFindInt(NDorder[i],2*(subd-1),seps+2*subd,&loc);CHKERRQ(ierr);
loc = loc < 0 ? -(loc+1)/2 : loc/2;
locals[i] = level[loc];
}
} else locals[i] = loc/2;
}
ierr = PetscFree3(sizes,seps,level);CHKERRQ(ierr);
#else
SETERRQ(pcomm,PETSC_ERR_SUP,"Need libptscotchparmetis.a compiled with -DSCOTCH_METIS_PREFIX");
#endif
} else {
velotab = NULL;
if (proc_weight_flg) {
ierr = PetscMalloc1(nparts,&vwgttab);CHKERRQ(ierr);
ierr = PetscMalloc1(nparts,&velotab);CHKERRQ(ierr);
for (j=0; j<nparts; j++) {
if (part->part_weights) vwgttab[j] = part->part_weights[j]*nparts;
else vwgttab[j] = 1.0;
}
for (i=0; i<nparts; i++) {
deltval = PetscAbsReal(vwgttab[i]-PetscFloorReal(vwgttab[i]+0.5));
if (deltval>0.01) {
for (j=0; j<nparts; j++) vwgttab[j] /= deltval;
}
}
for (i=0; i<nparts; i++) velotab[i] = (SCOTCH_Num)(vwgttab[i] + 0.5);
ierr = PetscFree(vwgttab);CHKERRQ(ierr);
}
vertlocnbr = mat->rmap->range[rank+1] - mat->rmap->range[rank];
edgelocnbr = adj->i[vertlocnbr];
veloloctab = part->vertex_weights;
edloloctab = adj->values;
/* detect whether all vertices are located at the same process in original graph */
for (p = 0; !mat->rmap->range[p+1] && p < nparts; ++p);
distributed = (mat->rmap->range[p+1] == mat->rmap->N) ? PETSC_FALSE : PETSC_TRUE;
if (distributed) {
SCOTCH_Arch archdat;
SCOTCH_Dgraph grafdat;
SCOTCH_Dmapping mappdat;
SCOTCH_Strat stradat;
ierr = SCOTCH_dgraphInit(&grafdat,comm);CHKERRQ(ierr);
ierr = SCOTCH_dgraphBuild(&grafdat,0,vertlocnbr,vertlocnbr,adj->i,adj->i+1,veloloctab,
NULL,edgelocnbr,edgelocnbr,adj->j,NULL,edloloctab);CHKERRQ(ierr);
#if defined(PETSC_USE_DEBUG)
ierr = SCOTCH_dgraphCheck(&grafdat);CHKERRQ(ierr);
#endif
ierr = SCOTCH_archInit(&archdat);CHKERRQ(ierr);
ierr = SCOTCH_stratInit(&stradat);CHKERRQ(ierr);
ierr = SCOTCH_stratDgraphMapBuild(&stradat,scotch->strategy,nparts,nparts,scotch->imbalance);CHKERRQ(ierr);
if (velotab) {
ierr = SCOTCH_archCmpltw(&archdat,nparts,velotab);CHKERRQ(ierr);
} else {
ierr = SCOTCH_archCmplt( &archdat,nparts);CHKERRQ(ierr);
}
ierr = SCOTCH_dgraphMapInit(&grafdat,&mappdat,&archdat,locals);CHKERRQ(ierr);
ierr = SCOTCH_dgraphMapCompute(&grafdat,&mappdat,&stradat);CHKERRQ(ierr);
SCOTCH_dgraphMapExit(&grafdat,&mappdat);
SCOTCH_archExit(&archdat);
SCOTCH_stratExit(&stradat);
SCOTCH_dgraphExit(&grafdat);
} else if (rank == p) {
SCOTCH_Graph grafdat;
SCOTCH_Strat stradat;
ierr = SCOTCH_graphInit(&grafdat);CHKERRQ(ierr);
ierr = SCOTCH_graphBuild(&grafdat,0,vertlocnbr,adj->i,adj->i+1,veloloctab,NULL,edgelocnbr,adj->j,edloloctab);CHKERRQ(ierr);
#if defined(PETSC_USE_DEBUG)
ierr = SCOTCH_graphCheck(&grafdat);CHKERRQ(ierr);
#endif
ierr = SCOTCH_stratInit(&stradat);CHKERRQ(ierr);
ierr = SCOTCH_stratGraphMapBuild(&stradat,scotch->strategy,nparts,scotch->imbalance);CHKERRQ(ierr);
ierr = SCOTCH_graphPart(&grafdat,nparts,&stradat,locals);CHKERRQ(ierr);
SCOTCH_stratExit(&stradat);
SCOTCH_graphExit(&grafdat);
}
ierr = PetscFree(velotab);CHKERRQ(ierr);
}
ierr = MPI_Comm_free(&comm);CHKERRQ(ierr);
if (bs > 1) {
PetscInt *newlocals;
ierr = PetscMalloc1(bs*mat->rmap->n,&newlocals);CHKERRQ(ierr);
for (i=0;i<mat->rmap->n;i++) {
for (j=0;j<bs;j++) {
newlocals[bs*i+j] = locals[i];
}
}
ierr = PetscFree(locals);CHKERRQ(ierr);
ierr = ISCreateGeneral(pcomm,bs*mat->rmap->n,newlocals,PETSC_OWN_POINTER,partitioning);CHKERRQ(ierr);
} else {
ierr = ISCreateGeneral(pcomm,mat->rmap->n,locals,PETSC_OWN_POINTER,partitioning);CHKERRQ(ierr);
}
if (useND) {
IS ndis;
if (bs > 1) {
ierr = ISCreateBlock(pcomm,bs,mat->rmap->n,NDorder,PETSC_OWN_POINTER,&ndis);CHKERRQ(ierr);
} else {
ierr = ISCreateGeneral(pcomm,mat->rmap->n,NDorder,PETSC_OWN_POINTER,&ndis);CHKERRQ(ierr);
}
ierr = ISSetPermutation(ndis);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject)(*partitioning),"_petsc_matpartitioning_ndorder",(PetscObject)ndis);CHKERRQ(ierr);
ierr = ISDestroy(&ndis);CHKERRQ(ierr);
}
if (!flg) {
ierr = MatDestroy(&mat);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Graph grafdat; /* Source graph */
SCOTCH_Num grafflag; /* Source graph properties */
SCOTCH_Arch archdat; /* Target architecture */
SCOTCH_Strat stradat; /* Mapping strategy */
SCOTCH_Mapping mapdat; /* Mapping data */
Clock runtime[2]; /* Timing variables */
double kbalval; /* Imbalance tolerance value */
int flagval;
SCOTCH_Num straval;
char * straptr;
int i, j;
flagval = C_FLAGNONE; /* Default behavior */
straval = 0; /* No strategy flags */
straptr = NULL;
i = strlen (argv[0]);
if ((i >= 5) && (strncmp (argv[0] + i - 5, "gpart", 5) == 0)) {
flagval |= C_FLAGPART;
C_paraNbr = 1; /* One more parameter */
C_fileNbr = 3; /* One less file to provide */
errorProg ("gpart");
}
else
errorProg ("gmap");
intRandInit ();
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
grafflag = 0; /* Use vertex and edge weights */
SCOTCH_stratInit (&stradat); /* Set default mapping strategy */
kbalval = 0.01; /* Set default load imbalance value */
for (i = 0; i < C_FILENBR; i ++) /* Set default stream pointers */
C_fileTab[i].pntr = (C_fileTab[i].mode[0] == 'r') ? stdin : stdout;
for (i = 1; i < argc; i ++) { /* Loop for all option codes */
if ((argv[i][0] != '-') || (argv[i][1] == '\0') || (argv[i][1] == '.')) { /* If found a file name */
if (C_paraNum < C_paraNbr) { /* If number of parameters not reached */
if ((C_partNbr = atoi (argv[i])) < 1) /* Get the number of parts */
errorPrint ("main: invalid number of parts (\"%s\")", argv[i]);
C_paraNum ++;
continue; /* Process the other parameters */
}
if (C_fileNum < C_fileNbr) /* A file name has been given */
C_fileTab[C_fileNum ++].name = argv[i];
else
errorPrint ("main: too many file names given");
}
else { /* If found an option name */
switch (argv[i][1]) {
case 'B' :
case 'b' :
flagval |= C_FLAGKBALVAL;
kbalval = atof (&argv[i][2]);
if ((kbalval < 0.0) ||
(kbalval > 1.0) ||
((kbalval == 0.0) &&
((argv[i][2] != '0') && (argv[i][2] != '.')))) {
errorPrint ("main: invalid load imbalance ratio");
}
break;
case 'C' :
case 'c' : /* Strategy selection parameters */
for (j = 2; argv[i][j] != '\0'; j ++) {
switch (argv[i][j]) {
case 'B' :
case 'b' :
straval |= SCOTCH_STRATBALANCE;
break;
case 'Q' :
case 'q' :
straval |= SCOTCH_STRATQUALITY;
break;
case 'S' :
case 's' :
straval |= SCOTCH_STRATSPEED;
break;
case 'T' :
case 't' :
straval |= SCOTCH_STRATSAFETY;
break;
default :
errorPrint ("main: invalid strategy selection option (\"%c\")", argv[i][j]);
}
}
break;
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'M' :
case 'm' :
straptr = &argv[i][2];
SCOTCH_stratExit (&stradat);
SCOTCH_stratInit (&stradat);
SCOTCH_stratGraphMap (&stradat, straptr);
break;
case 'S' :
case 's' : /* Source graph parameters */
for (j = 2; argv[i][j] != '\0'; j ++) {
switch (argv[i][j]) {
case 'E' :
case 'e' :
grafflag |= 2; /* Do not load edge weights */
break;
case 'V' :
case 'v' :
grafflag |= 1; /* Do not load vertex weights */
break;
default :
errorPrint ("main: invalid source graph option (\"%c\")", argv[i][j]);
}
}
break;
case 'V' :
fprintf (stderr, "gmap/gpart, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 2004,2007,2008,2010 ENSEIRB, INRIA & CNRS, France\n");
fprintf (stderr, "This software is libre/free software under CeCILL-C -- see the user's manual for more information\n");
return (0);
case 'v' : /* Output control info */
for (j = 2; argv[i][j] != '\0'; j ++) {
switch (argv[i][j]) {
case 'M' :
case 'm' :
flagval |= C_FLAGVERBMAP;
break;
case 'S' :
case 's' :
flagval |= C_FLAGVERBSTR;
break;
case 'T' :
case 't' :
flagval |= C_FLAGVERBTIM;
break;
default :
errorPrint ("main: unprocessed parameter \"%c\" in \"%s\"", argv[i][j], argv[i]);
}
}
break;
default :
errorPrint ("main: unprocessed option (\"%s\")", argv[i]);
}
}
}
if ((flagval & C_FLAGPART) != 0) { /* If program run as the partitioner */
C_fileTab[3].name = C_fileTab[2].name; /* Put provided file names at their right place */
C_fileTab[2].name = C_fileTab[1].name;
C_fileTab[1].name = "-";
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
clockInit (&runtime[0]);
clockStart (&runtime[0]);
SCOTCH_graphInit (&grafdat); /* Create graph structure */
SCOTCH_graphLoad (&grafdat, C_filepntrsrcinp, -1, grafflag); /* Read source graph */
SCOTCH_archInit (&archdat); /* Create architecture structure */
if ((flagval & C_FLAGPART) != 0) /* If program run as the partitioner */
SCOTCH_archCmplt (&archdat, C_partNbr); /* Create a complete graph of proper size */
else {
SCOTCH_archLoad (&archdat, C_filepntrtgtinp); /* Read target architecture */
C_partNbr = SCOTCH_archSize (&archdat);
}
if ((straval != 0) || ((flagval & C_FLAGKBALVAL) != 0)) {
if (straptr != NULL)
errorPrint ("main: options '-b' / '-c' and '-m' are exclusive");
SCOTCH_stratGraphMapBuild (&stradat, straval, (SCOTCH_Num) C_partNbr, kbalval);
}
clockStop (&runtime[0]); /* Get input time */
clockInit (&runtime[1]);
clockStart (&runtime[1]);
SCOTCH_graphMapInit (&grafdat, &mapdat, &archdat, NULL);
SCOTCH_graphMapCompute (&grafdat, &mapdat, &stradat); /* Perform mapping */
clockStop (&runtime[1]); /* Get computation time */
clockStart (&runtime[0]);
SCOTCH_graphMapSave (&grafdat, &mapdat, C_filepntrmapout); /* Write mapping */
clockStop (&runtime[0]); /* Get output time */
if (flagval & C_FLAGVERBSTR) {
fprintf (C_filepntrlogout, "S\tStrat=");
SCOTCH_stratSave (&stradat, C_filepntrlogout);
putc ('\n', C_filepntrlogout);
}
if (flagval & C_FLAGVERBTIM) {
fprintf (C_filepntrlogout, "T\tMapping\t\t%g\nT\tI/O\t\t%g\nT\tTotal\t\t%g\n",
(double) clockVal (&runtime[1]),
(double) clockVal (&runtime[0]),
(double) clockVal (&runtime[0]) +
(double) clockVal (&runtime[1]));
}
if (flagval & C_FLAGVERBMAP)
SCOTCH_graphMapView (&grafdat, &mapdat, C_filepntrlogout);
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
SCOTCH_graphMapExit (&grafdat, &mapdat);
SCOTCH_graphExit (&grafdat);
SCOTCH_stratExit (&stradat);
SCOTCH_archExit (&archdat);
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
static
int
graphMapCompute2 (
SCOTCH_Graph * const grafptr, /*+ Graph to order +*/
SCOTCH_Mapping * const mappptr, /*+ Mapping to compute +*/
SCOTCH_Mapping * const mapoptr, /*+ Old mapping +*/
const double emraval, /*+ Edge migration ratio +*/
const SCOTCH_Num * vmlotab, /*+ Vertex migration cost array +*/
Gnum vfixval, /*+ Equal to 0 if no fixed vertices +*/
SCOTCH_Strat * const straptr) /*+ Mapping strategy +*/
{
Kgraph mapgrafdat; /* Effective mapping graph */
const Strat * mapstraptr; /* Pointer to mapping strategy */
LibMapping * restrict lmapptr;
LibMapping * restrict lmaoptr;
Anum * pfixtax;
Gnum baseval;
Anum * parttax; /* Partition array */
Anum * parotax; /* Old partition array */
Gnum crloval; /* Coefficient load for regular edges */
Gnum cmloval; /* Coefficient load for migration edges */
const Gnum * vmlotax; /* Vertex migration cost array */
Gnum vertnum;
Gnum vertnnd;
Gnum vertnbr;
int o;
lmapptr = (LibMapping *) mappptr;
#ifdef SCOTCH_DEBUG_GRAPH2
if ((Graph *) grafptr != lmapptr->grafptr) {
errorPrint ("graphMapCompute2: output mapping does not correspond to input graph");
return (1);
}
if (graphCheck ((Graph *) grafptr) != 0) { /* Vertex loads can be 0 if we have fixed vertices */
errorPrint ("graphMapCompute2: invalid input graph");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
if (*((Strat **) straptr) == NULL) { /* Set default mapping strategy if necessary */
ArchDom archdomnorg;
archDomFrst (lmapptr->archptr, &archdomnorg);
SCOTCH_stratGraphMapBuild (straptr, SCOTCH_STRATDEFAULT, archDomSize (lmapptr->archptr, &archdomnorg), 0.01);
}
mapstraptr = *((Strat **) straptr);
if (mapstraptr->tabl != &kgraphmapststratab) {
errorPrint ("graphMapCompute2: not a graph mapping strategy");
return (1);
}
baseval = lmapptr->grafptr->baseval;
vertnbr = lmapptr->grafptr->vertnbr;
if (mapoptr != NULL) { /* We are doing a repartitioning */
LibMapping * lmaoptr;
Gnum numeval;
Gnum denoval;
lmaoptr = (LibMapping *) mapoptr;
#ifdef SCOTCH_DEBUG_GRAPH2
if (lmapptr->grafptr != lmaoptr->grafptr) {
errorPrint ("graphMapCompute2: output and old mapping must correspond to the same graph");
return (1);
}
if (lmapptr->archptr != lmaoptr->archptr) {
errorPrint ("graphMapCompute2: output and old mapping must correspond to the same architecture");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
parotax = lmaoptr->parttab - baseval;
vmlotax = (vmlotab != NULL) ? vmlotab - baseval : NULL;
numeval = (INT) ((emraval * 100.0) + 0.5);
denoval = intGcd (numeval, 100);
cmloval = numeval / denoval;
crloval = 100 / denoval;
}
else {
parotax = NULL;
vmlotax = NULL;
cmloval =
crloval = 1;
}
parttax = NULL;
if (vfixval != 0) { /* We have fixed vertices */
#ifdef SCOTCH_DEBUG_GRAPH2
if (lmapptr->parttab == NULL) { /* We must have fixed vertices information */
errorPrint ("graphMapCompute2: missing output mapping part array");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
pfixtax = lmapptr->parttab - baseval;
if ((parttax = (Anum *) memAlloc (vertnbr * sizeof (Anum))) == NULL) {
errorPrint ("graphMapCompute2: out of memory (1)");
return (1);
}
memSet (parttax, 0, vertnbr * sizeof (Anum)); /* All vertices mapped to first domain */
parttax -= baseval;
} else {
pfixtax = NULL;
if (lmapptr->parttab == NULL) { /* If user mapping not initialized */
errorPrint ("graphMapCompute2: invalid user mapping");
return (1);
}
parttax = lmapptr->parttab - baseval;
}
intRandInit (); /* Check that random number generator is initialized */
if (kgraphInit (&mapgrafdat, (Graph *) grafptr, lmapptr->archptr, NULL, parttax, parotax, crloval, cmloval, vmlotax, pfixtax) != 0)
return (1);
o = 0;
if (mapgrafdat.vfixnbr != mapgrafdat.s.vertnbr) { /* Perform mapping if not all fixed vertices */
o = kgraphMapSt (&mapgrafdat, mapstraptr);
lmapptr->parttab -= baseval;
for (vertnum = baseval, vertnnd = vertnum + lmapptr->grafptr->vertnbr;
vertnum < vertnnd; vertnum ++)
lmapptr->parttab[vertnum] = archDomNum (lmapptr->archptr, &mapgrafdat.m.domntab[mapgrafdat.m.parttax[vertnum]]);
lmapptr->parttab += baseval;
}
if (vfixval != 0) /* We have fixed vertices */
memFree (parttax + baseval);
kgraphExit (&mapgrafdat);
return (o);
}
