static
int
_SCOTCH_METIS_PartGraph (
const int * const n,
const int * const xadj,
const int * const adjncy,
const int * const vwgt,
const int * const adjwgt,
const int * const numflag,
const int * const nparts,
int * const part)
{
SCOTCH_Graph grafdat; /* Scotch graph object to interface with libScotch */
SCOTCH_Strat stradat;
SCOTCH_Num baseval;
SCOTCH_Num vertnbr;
int o;
if (sizeof (SCOTCH_Num) != sizeof (int)) {
errorPrint ("METIS_PartGraph* (as of SCOTCH): SCOTCH_Num type should equate to int");
return (1);
}
SCOTCH_graphInit (&grafdat);
baseval = *numflag;
vertnbr = *n;
o = 1; /* Assume something will go wrong */
if (SCOTCH_graphBuild (&grafdat,
baseval, vertnbr, xadj, xadj + 1, vwgt, NULL,
xadj[vertnbr] - baseval, adjncy, adjwgt) == 0) {
SCOTCH_stratInit (&stradat);
#ifdef SCOTCH_DEBUG_ALL
if (SCOTCH_graphCheck (&grafdat) == 0) /* TRICK: next instruction called only if graph is consistent */
#endif /* SCOTCH_DEBUG_ALL */
o = SCOTCH_graphPart (&grafdat, *nparts, &stradat, part);
SCOTCH_stratExit (&stradat);
}
SCOTCH_graphExit (&grafdat);
if (baseval != 0) { /* MeTiS part array is based, Scotch is not */
SCOTCH_Num vertnum;
for (vertnum = 0; vertnum < vertnbr; vertnum ++)
part[vertnum] += baseval;
}
return (o);
}
int
METISNAMEU(METIS_NodeWND) (
const SCOTCH_Num * const n,
const SCOTCH_Num * const xadj,
const SCOTCH_Num * const adjncy,
const SCOTCH_Num * const vwgt,
const SCOTCH_Num * const numflag,
const SCOTCH_Num * const options,
SCOTCH_Num * const perm,
SCOTCH_Num * const iperm)
{
SCOTCH_Graph grafdat; /* Scotch graph object to interface with libScotch */
SCOTCH_Ordering ordedat; /* Scotch ordering object to interface with libScotch */
SCOTCH_Strat stradat;
int o;
o = METIS_ERROR; /* Assume an error */
SCOTCH_graphInit (&grafdat);
if (SCOTCH_graphBuild (&grafdat,
*numflag, *n, xadj, xadj + 1, vwgt, NULL,
xadj[*n] - *numflag, adjncy, NULL) == 0) {
SCOTCH_stratInit (&stradat);
#ifdef SCOTCH_DEBUG_ALL
if (SCOTCH_graphCheck (&grafdat) == 0) /* TRICK: next instruction called only if graph is consistent */
#endif /* SCOTCH_DEBUG_ALL */
{
if (SCOTCH_graphOrderInit (&grafdat, &ordedat, iperm, perm, /* MeTiS and Scotch have opposite definitions for (inverse) permutations */
NULL, NULL, NULL) == 0) {
if (SCOTCH_graphOrderCompute (&grafdat, &ordedat, &stradat) == 0)
o = METIS_OK;
SCOTCH_graphOrderExit (&grafdat, &ordedat);
}
}
SCOTCH_stratExit (&stradat);
}
SCOTCH_graphExit (&grafdat);
return (o);
}
void AlgPTScotch<Adapter>::partition(
const RCP<PartitioningSolution<Adapter> > &solution
)
{
HELLO;
size_t numGlobalParts = solution->getTargetGlobalNumberOfParts();
SCOTCH_Num partnbr=0;
TPL_Traits<SCOTCH_Num, size_t>::ASSIGN_TPL_T(partnbr, numGlobalParts, env);
#ifdef HAVE_ZOLTAN2_MPI
int ierr = 0;
int me = problemComm->getRank();
const SCOTCH_Num baseval = 0; // Base value for array indexing.
// GraphModel returns GNOs from base 0.
SCOTCH_Strat stratstr; // Strategy string
// TODO: Set from parameters
SCOTCH_stratInit(&stratstr);
// Allocate and initialize PTScotch Graph data structure.
SCOTCH_Dgraph *gr = SCOTCH_dgraphAlloc(); // Scotch distributed graph
ierr = SCOTCH_dgraphInit(gr, mpicomm);
env->globalInputAssertion(__FILE__, __LINE__, "SCOTCH_dgraphInit",
!ierr, BASIC_ASSERTION, problemComm);
// Get vertex info
ArrayView<const gno_t> vtxID;
ArrayView<StridedData<lno_t, scalar_t> > xyz;
ArrayView<StridedData<lno_t, scalar_t> > vwgts;
size_t nVtx = model->getVertexList(vtxID, xyz, vwgts);
SCOTCH_Num vertlocnbr=0;
TPL_Traits<SCOTCH_Num, size_t>::ASSIGN_TPL_T(vertlocnbr, nVtx, env);
SCOTCH_Num vertlocmax = vertlocnbr; // Assumes no holes in global nums.
// Get edge info
ArrayView<const gno_t> edgeIds;
ArrayView<const int> procIds;
ArrayView<const lno_t> offsets;
ArrayView<StridedData<lno_t, scalar_t> > ewgts;
size_t nEdge = model->getEdgeList(edgeIds, procIds, offsets, ewgts);
SCOTCH_Num edgelocnbr=0;
TPL_Traits<SCOTCH_Num, size_t>::ASSIGN_TPL_T(edgelocnbr, nEdge, env);
const SCOTCH_Num edgelocsize = edgelocnbr; // Assumes adj array is compact.
SCOTCH_Num *vertloctab; // starting adj/vtx
TPL_Traits<SCOTCH_Num, lno_t>::ASSIGN_TPL_T_ARRAY(&vertloctab, offsets, env);
SCOTCH_Num *edgeloctab; // adjacencies
TPL_Traits<SCOTCH_Num, gno_t>::ASSIGN_TPL_T_ARRAY(&edgeloctab, edgeIds, env);
// We don't use these arrays, but we need them as arguments to Scotch.
SCOTCH_Num *vendloctab = NULL; // Assume consecutive storage for adj
SCOTCH_Num *vlblloctab = NULL; // Vertex label array
SCOTCH_Num *edgegsttab = NULL; // Array for ghost vertices
// Get weight info.
SCOTCH_Num *velotab = NULL; // Vertex weights
SCOTCH_Num *edlotab = NULL; // Edge weights
int nVwgts = model->getNumWeightsPerVertex();
int nEwgts = model->getNumWeightsPerEdge();
if (nVwgts > 1 && me == 0) {
std::cerr << "Warning: NumWeightsPerVertex is " << nVwgts
<< " but Scotch allows only one weight. "
<< " Zoltan2 will use only the first weight per vertex."
<< std::endl;
}
if (nEwgts > 1 && me == 0) {
std::cerr << "Warning: NumWeightsPerEdge is " << nEwgts
<< " but Scotch allows only one weight. "
<< " Zoltan2 will use only the first weight per edge."
<< std::endl;
}
if (nVwgts) {
velotab = new SCOTCH_Num[nVtx+1]; // +1 since Scotch wants all procs
// to have non-NULL arrays
scale_weights(nVtx, vwgts[0], velotab);
}
if (nEwgts) {
edlotab = new SCOTCH_Num[nEdge+1]; // +1 since Scotch wants all procs
// to have non-NULL arrays
scale_weights(nEdge, ewgts[0], edlotab);
}
// Build PTScotch distributed data structure
ierr = SCOTCH_dgraphBuild(gr, baseval, vertlocnbr, vertlocmax,
vertloctab, vendloctab, velotab, vlblloctab,
edgelocnbr, edgelocsize,
edgeloctab, edgegsttab, edlotab);
env->globalInputAssertion(__FILE__, __LINE__, "SCOTCH_dgraphBuild",
!ierr, BASIC_ASSERTION, problemComm);
// Create array for Scotch to return results in.
ArrayRCP<part_t> partList(new part_t[nVtx], 0, nVtx,true);
SCOTCH_Num *partloctab = NULL;
if (nVtx && (sizeof(SCOTCH_Num) == sizeof(part_t))) {
// Can write directly into the solution's memory
partloctab = (SCOTCH_Num *) partList.getRawPtr();
}
else {
// Can't use solution memory directly; will have to copy later.
// Note: Scotch does not like NULL arrays, so add 1 to always have non-null.
// ParMETIS has this same "feature." See Zoltan bug 4299.
partloctab = new SCOTCH_Num[nVtx+1];
}
// Get target part sizes
float *partsizes = new float[numGlobalParts];
if (!solution->criteriaHasUniformPartSizes(0))
for (size_t i=0; i<numGlobalParts; i++)
partsizes[i] = solution->getCriteriaPartSize(0, i);
else
for (size_t i=0; i<numGlobalParts; i++)
partsizes[i] = 1.0 / float(numGlobalParts);
// Allocate and initialize PTScotch target architecture data structure
SCOTCH_Arch archdat;
SCOTCH_archInit(&archdat);
SCOTCH_Num velosum = 0;
SCOTCH_dgraphSize (gr, &velosum, NULL, NULL, NULL);
SCOTCH_Num *goalsizes = new SCOTCH_Num[partnbr];
// TODO: The goalsizes are set as in Zoltan; not sure it is correct there
// or here.
// It appears velosum is global NUMBER of vertices, not global total
// vertex weight. I think we should use the latter.
// Fix this when we add vertex weights.
for (SCOTCH_Num i = 0; i < partnbr; i++)
goalsizes[i] = SCOTCH_Num(ceil(velosum * partsizes[i]));
delete [] partsizes;
SCOTCH_archCmpltw(&archdat, partnbr, goalsizes);
// Call partitioning; result returned in partloctab.
ierr = SCOTCH_dgraphMap(gr, &archdat, &stratstr, partloctab);
env->globalInputAssertion(__FILE__, __LINE__, "SCOTCH_dgraphMap",
!ierr, BASIC_ASSERTION, problemComm);
SCOTCH_archExit(&archdat);
delete [] goalsizes;
// TODO - metrics
#ifdef SHOW_ZOLTAN2_SCOTCH_MEMORY
int me = env->comm_->getRank();
#endif
#ifdef HAVE_SCOTCH_ZOLTAN2_GETMEMORYMAX
if (me == 0){
size_t scotchBytes = SCOTCH_getMemoryMax();
std::cout << "Rank " << me << ": Maximum bytes used by Scotch: ";
std::cout << scotchBytes << std::endl;
}
#endif
// Clean up PTScotch
SCOTCH_dgraphExit(gr);
free(gr);
SCOTCH_stratExit(&stratstr);
// Load answer into the solution.
if ((sizeof(SCOTCH_Num) != sizeof(part_t)) || (nVtx == 0)) {
for (size_t i = 0; i < nVtx; i++) partList[i] = partloctab[i];
delete [] partloctab;
}
solution->setParts(partList);
env->memory("Zoltan2-Scotch: After creating solution");
// Clean up copies made due to differing data sizes.
TPL_Traits<SCOTCH_Num, lno_t>::DELETE_TPL_T_ARRAY(&vertloctab);
TPL_Traits<SCOTCH_Num, gno_t>::DELETE_TPL_T_ARRAY(&edgeloctab);
if (nVwgts) delete [] velotab;
if (nEwgts) delete [] edlotab;
#else // DO NOT HAVE_MPI
// TODO: Handle serial case with calls to Scotch.
// TODO: For now, assign everything to rank 0 and assume only one part.
// TODO: Can probably use the code above for loading solution,
// TODO: instead of duplicating it here.
// TODO
// TODO: Actual logic should call Scotch when number of processes == 1.
ArrayView<const gno_t> vtxID;
ArrayView<StridedData<lno_t, scalar_t> > xyz;
ArrayView<StridedData<lno_t, scalar_t> > vwgts;
size_t nVtx = model->getVertexList(vtxID, xyz, vwgts);
ArrayRCP<part_t> partList(new part_t[nVtx], 0, nVtx, true);
for (size_t i = 0; i < nVtx; i++) partList[i] = 0;
solution->setParts(partList);
#endif // DO NOT HAVE_MPI
}
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);
}
void
METISNAMEU(ParMETIS_V3_PartKway) (
const SCOTCH_Num * const vtxdist,
SCOTCH_Num * const xadj,
SCOTCH_Num * const adjncy,
SCOTCH_Num * const vwgt,
SCOTCH_Num * const adjwgt,
const SCOTCH_Num * const wgtflag,
const SCOTCH_Num * const numflag,
const SCOTCH_Num * const ncon, /* Not used */
const SCOTCH_Num * const nparts,
const float * const tpwgts,
const float * const ubvec, /* Not used */
const SCOTCH_Num * const options, /* Not used */
SCOTCH_Num * const edgecut,
SCOTCH_Num * const part,
MPI_Comm * comm)
{
MPI_Comm proccomm;
int procglbnbr;
int proclocnum;
SCOTCH_Num baseval;
SCOTCH_Arch archdat;
SCOTCH_Dgraph grafdat; /* Scotch distributed graph object to interface with libScotch */
SCOTCH_Dmapping mappdat; /* Scotch distributed mapping object to interface with libScotch */
SCOTCH_Strat stradat;
SCOTCH_Num vertlocnbr;
SCOTCH_Num * veloloctab;
SCOTCH_Num edgelocnbr;
SCOTCH_Num * edloloctab;
SCOTCH_Num * velotab;
double * vwgttab;
SCOTCH_Num i;
if ((vwgttab = malloc (*nparts * sizeof (double))) == NULL)
return;
if ((velotab = malloc (*nparts * sizeof (SCOTCH_Num))) == NULL) {
free (vwgttab);
return;
}
for (i = 0; i < *nparts; i ++)
vwgttab[i] = (double) tpwgts[i] * (double) (*nparts);
for (i = 0; i < *nparts; i ++) {
double deltval;
deltval = fabs (vwgttab[i] - floor (vwgttab[i] + 0.5));
if (deltval > 0.01) {
SCOTCH_Num j;
deltval = 1.0 / deltval;
for (j = 0; j < *nparts; j ++)
vwgttab[j] *= deltval;
}
}
for (i = 0; i < *nparts; i ++)
velotab[i] = (SCOTCH_Num) (vwgttab[i] + 0.5);
proccomm = *comm;
if (SCOTCH_dgraphInit (&grafdat, proccomm) != 0)
return;
MPI_Comm_size (proccomm, &procglbnbr);
MPI_Comm_rank (proccomm, &proclocnum);
baseval = *numflag;
vertlocnbr = vtxdist[proclocnum + 1] - vtxdist[proclocnum];
edgelocnbr = xadj[vertlocnbr] - baseval;
veloloctab = ((vwgt != NULL) && ((*wgtflag & 2) != 0)) ? vwgt : NULL;
edloloctab = ((adjwgt != NULL) && ((*wgtflag & 1) != 0)) ? adjwgt : NULL;
if (SCOTCH_dgraphBuild (&grafdat, baseval,
vertlocnbr, vertlocnbr, xadj, xadj + 1, veloloctab, NULL,
edgelocnbr, edgelocnbr, adjncy, NULL, edloloctab) == 0) {
SCOTCH_stratInit (&stradat);
#ifdef SCOTCH_DEBUG_ALL
if (SCOTCH_dgraphCheck (&grafdat) == 0) /* TRICK: next instruction called only if graph is consistent */
#endif /* SCOTCH_DEBUG_ALL */
{
SCOTCH_archInit (&archdat);
if ((SCOTCH_archCmpltw (&archdat, *nparts, velotab) == 0) &&
(SCOTCH_dgraphMapInit (&grafdat, &mappdat, &archdat, part) == 0)) {
SCOTCH_dgraphMapCompute (&grafdat, &mappdat, &stradat);
SCOTCH_dgraphMapExit (&grafdat, &mappdat);
}
SCOTCH_archExit (&archdat);
}
SCOTCH_stratExit (&stradat);
}
SCOTCH_dgraphExit (&grafdat);
*edgecut = 0; /* TODO : compute real edge cut for people who might want it */
free (vwgttab);
free (velotab);
if (baseval != 0) { /* MeTiS part array is based, Scotch is not */
SCOTCH_Num vertlocnum;
for (vertlocnum = 0; vertlocnum < vertlocnbr; vertlocnum ++)
part[vertlocnum] += baseval;
}
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Graph grafdat;
SCOTCH_Strat stradat;
SCOTCH_Num baseval;
SCOTCH_Num partnbr;
SCOTCH_Num partnum;
SCOTCH_Num * restrict parttax;
SCOTCH_Num vertnbr;
SCOTCH_Num vertnum;
SCOTCH_Num * verttab;
SCOTCH_Num * vendtab;
SCOTCH_Num * velotab;
SCOTCH_Num * vlbltab;
SCOTCH_Num * edgetax;
SCOTCH_Num * restrict flagtab;
SCOTCH_Num * restrict loadtab;
SCOTCH_Num loadmin;
SCOTCH_Num loadmax;
SCOTCH_Num loadsum;
double loadavg;
FILE * fileptr;
SCOTCH_errorProg (argv[0]);
if ((argc < 4) || (argc > 5)) {
SCOTCH_errorPrint ("usage: %s nparts input_source_graph_file output_mapping_file [strategy]", argv[0]);
exit (EXIT_FAILURE);
}
if ((partnbr = (SCOTCH_Num) atoi (argv[1])) < 1) {
SCOTCH_errorPrint ("main: invalid number of parts (\"%s\")", argv[1]);
exit (EXIT_FAILURE);
}
if (SCOTCH_stratInit (&stradat) != 0) {
SCOTCH_errorPrint ("main: cannot initialize strategy");
exit (EXIT_FAILURE);
}
if (argc == 5) {
if (SCOTCH_stratGraphPartOvl (&stradat, argv[4]) != 0) {
SCOTCH_errorPrint ("main: invalid user-provided strategy");
exit (EXIT_FAILURE);
}
}
if (SCOTCH_graphInit (&grafdat) != 0) {
SCOTCH_errorPrint ("main: cannot initialize graph");
exit (EXIT_FAILURE);
}
if ((fileptr = fopen (argv[2], "r")) == NULL) {
SCOTCH_errorPrint ("main: cannot open file (1)");
exit (EXIT_FAILURE);
}
if (SCOTCH_graphLoad (&grafdat, fileptr, -1, 0) != 0) {
SCOTCH_errorPrint ("main: cannot load graph");
exit (EXIT_FAILURE);
}
fclose (fileptr);
SCOTCH_graphData (&grafdat, &baseval, &vertnbr, &verttab, &vendtab, &velotab, &vlbltab, NULL, &edgetax, NULL);
if (((parttax = malloc (vertnbr * sizeof (SCOTCH_Num))) == NULL) ||
((flagtab = malloc (partnbr * sizeof (SCOTCH_Num))) == NULL) ||
((loadtab = malloc (partnbr * sizeof (SCOTCH_Num))) == NULL)) {
SCOTCH_errorPrint ("main: out of memory");
exit (EXIT_FAILURE);
}
if (SCOTCH_graphPartOvl (&grafdat, partnbr, &stradat, parttax) != 0) { /* Parttax is not based yet */
SCOTCH_errorPrint ("main: cannot compute mapping");
exit (EXIT_FAILURE);
}
edgetax -= baseval;
parttax -= baseval;
memset (loadtab, 0, partnbr * sizeof (SCOTCH_Num)); /* Part loads set to 0 */
memset (flagtab, ~0, partnbr * sizeof (SCOTCH_Num)); /* Flags set to invalid vertex number */
for (vertnum = 0; vertnum < vertnbr; vertnum ++) {
SCOTCH_Num veloval;
SCOTCH_Num partval;
veloval = (velotab == NULL) ? 1 : velotab[vertnum];
partval = parttax[vertnum + baseval]; /* vertnum is not based */
if (partval >= 0) /* If vertex belongs to one part only */
loadtab[partval] += veloval; /* Add vertex load to this part */
else { /* Vertex belongs to several parts */
SCOTCH_Num edgenum;
for (edgenum = verttab[vertnum]; edgenum < vendtab[vertnum]; edgenum ++) {
SCOTCH_Num vertend;
SCOTCH_Num partend;
vertend = edgetax[edgenum];
partend = parttax[vertend]; /* vertend is based */
if (partend < 0) /* If neighbor has no identifiable part */
continue;
if (flagtab[partend] == vertnum) /* If neighbor part already accounted for, skip it */
continue;
loadtab[partend] += veloval; /* Vertex load contributes to this part */
flagtab[partend] = vertnum; /* Record a contribution has been made */
}
}
}
loadsum =
loadmax = 0;
loadmin = SCOTCH_NUMMAX;
for (partnum = 0; partnum < partnbr; partnum ++) {
loadsum += loadtab[partnum];
if (loadtab[partnum] > loadmax)
loadmax = loadtab[partnum];
if (loadtab[partnum] < loadmin)
loadmin = loadtab[partnum];
printf ("M\tCompload[%02ld]\t%ld\n",
(long) partnum,
(long) loadtab[partnum]);
}
loadavg = (double) loadsum / (double) partnbr;
printf ("M\tCompLoadAvg\t%g\n",
(double) loadavg);
printf ("M\tCompLoadMax/Avg\t%g\n",
(double) loadmax / loadavg);
if ((fileptr = fopen (argv[3], "w")) == NULL) {
SCOTCH_errorPrint ("main: cannot open file (2)");
exit (EXIT_FAILURE);
}
if (fprintf (fileptr, "%ld\n", (long) vertnbr) == EOF) {
SCOTCH_errorPrint ("main: bad output (1)");
exit (EXIT_FAILURE);
}
for (vertnum = 0; vertnum < vertnbr; vertnum ++) {
if (fprintf (fileptr, "%ld\t%ld\n",
(long) ((vlbltab == NULL) ? vertnum : vlbltab[vertnum]),
(long) parttax[vertnum + baseval]) == EOF) {
SCOTCH_errorPrint ("main: bad output (2)");
exit (EXIT_FAILURE);
}
}
fclose (fileptr);
free (loadtab);
free (flagtab);
free (parttax + baseval);
SCOTCH_stratExit (&stradat);
SCOTCH_graphExit (&grafdat);
exit (EXIT_SUCCESS);
}
/* Internal function : kPartBoxCompute
* it computes a new numbering of graph vertices, using a k-partitioning.
* Assuming that baseval of the graph is 1
*
* - graf : the input graph
* - vertNbr : the number of vertices
* - boxVertNbr : the number of vertices of each box
* - permVrtTab : the new numbering
*
* returning 0 if OK, 1 else
*/
int kPartBoxCompute(SCOTCH_Graph graf, int vertNbr, int boxVertNbr, SCOTCH_Num *permVrtTab) {
int boxNbr, vertIdx;
SCOTCH_Num logMaxVal, SupMaxVal, InfMaxVal, maxVal;
char s[200];
SCOTCH_Num *sortPartTb;
SCOTCH_Strat strat ;
SCOTCH_Arch arch;
/* Computing the number of boxes */
boxNbr = vertNbr / boxVertNbr;
if (boxNbr * boxVertNbr != vertNbr) {
boxNbr = boxNbr + 1;
}
/* Initializing SCOTCH functions */
CHECK_SCOTCH(SCOTCH_stratInit(&strat), "scotch_stratInit", 0) ;
CHECK_SCOTCH(SCOTCH_archVcmplt(&arch), "scotch_archVcmplt", 0) ;
sprintf(s, "m{vert=%d,low=r{job=t,map=t,poli=S,sep=m{type=h,vert=80,low=h{pass=10}f{bal=0.0005,move=80},asc=f{bal=0.005,move=80}}}}", vertNbr / boxVertNbr);
CHECK_SCOTCH(SCOTCH_stratGraphMap(&strat, s), "scotch_stratGraphMap", 0) ;
sortPartTb= (SCOTCH_Num *)M_calloc(2*vertNbr, sizeof(SCOTCH_Num), "boxCompute");
/* Partionning the graph */
CHECK_SCOTCH(SCOTCH_graphMap(&graf, &arch, &strat, sortPartTb), "scotch_graphMap", 0);
// Looking for the max value in sortPartTb and computing sortPartTb as
// followed :
// - sortPartTb[2i] is the box value
// - sortPartTb[2i+1] is the vertex number
maxVal = sortPartTb[0];
for (vertIdx = vertNbr - 1 ; vertIdx >= 0 ; vertIdx--) {
sortPartTb[2*vertIdx] = sortPartTb[vertIdx];
sortPartTb[2*vertIdx+1] = vertIdx + 1;
if (sortPartTb[vertIdx] > maxVal)
maxVal = sortPartTb[vertIdx];
}
// Determining the log of MaxVal
logMaxVal = 0;
while ( maxVal > 0) {
logMaxVal++;
maxVal >>= 1;
}
// Infering the interval in which box values will be
InfMaxVal = logMaxVal << logMaxVal;
SupMaxVal = (logMaxVal << (logMaxVal + 1)) - 1;
// Increasing box values until they are in the previous interval
for (vertIdx = 0 ; vertIdx < vertNbr ; vertIdx++) {
while (!(sortPartTb[2*vertIdx] >= InfMaxVal && sortPartTb[2*vertIdx] <= SupMaxVal)) {
sortPartTb[2*vertIdx] <<= 1;
}
}
// Sorting the tabular, which contains box values and vertex numbers
_SCOTCHintSort2asc1(sortPartTb, vertNbr);
/* Infering the new numbering */
for (vertIdx = 0; vertIdx < vertNbr ; vertIdx++) {
permVrtTab[sortPartTb[2*vertIdx + 1]] = vertIdx + 1;
}
SCOTCH_stratExit(&strat) ;
SCOTCH_archExit(&arch) ;
M_free(sortPartTb);
return 0;
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Num vertnbr; /* Number of vertices */
SCOTCH_Graph grafdat; /* Source graph */
SCOTCH_Ordering ordedat; /* Graph ordering */
SCOTCH_Num * permtab; /* Permutation array */
SCOTCH_Strat stradat; /* Ordering strategy */
SCOTCH_Num straval;
char * straptr;
int flagval;
Clock runtime[2]; /* Timing variables */
int i, j;
errorProg ("gord");
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
flagval = C_FLAGNONE; /* Default behavior */
straval = 0; /* No strategy flags */
straptr = NULL;
SCOTCH_stratInit (&stradat);
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_fileNum < C_FILEARGNBR) /* 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 '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' : /* Output separator mapping */
case 'm' :
flagval |= C_FLAGMAPOUT;
if (argv[i][2] != '\0')
C_filenamemapout = &argv[i][2];
break;
case 'O' : /* Ordering strategy */
case 'o' :
straptr = &argv[i][2];
SCOTCH_stratExit (&stradat);
SCOTCH_stratInit (&stradat);
SCOTCH_stratGraphOrder (&stradat, straptr);
break;
case 'T' : /* Output separator tree */
case 't' :
flagval |= C_FLAGTREOUT;
if (argv[i][2] != '\0')
C_filenametreout = &argv[i][2];
break;
case 'V' :
fprintf (stderr, "gord, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 2004,2007,2008,2010-2012 IPB, Universite de Bordeaux, 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 '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]);
}
}
}
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, 2); /* Read source graph */
SCOTCH_graphSize (&grafdat, &vertnbr, NULL); /* Get graph characteristics */
if (straval != 0) {
if (straptr != NULL)
errorPrint ("main: options '-c' and '-o' are exclusive");
SCOTCH_stratGraphOrderBuild (&stradat, straval, 0, 0.2);
}
clockStop (&runtime[0]); /* Get input time */
clockInit (&runtime[1]);
clockStart (&runtime[1]);
if ((permtab = (SCOTCH_Num *) memAlloc (vertnbr * sizeof (SCOTCH_Num))) == NULL) {
errorPrint ("main: out of memory");
return (1);
}
SCOTCH_graphOrderInit (&grafdat, &ordedat, permtab, NULL, NULL, NULL, NULL); /* Create ordering */
SCOTCH_graphOrderCompute (&grafdat, &ordedat, &stradat); /* Perform ordering */
clockStop (&runtime[1]); /* Get ordering time */
#ifdef SCOTCH_DEBUG_ALL
if (SCOTCH_graphOrderCheck (&grafdat, &ordedat) != 0)
return (1);
#endif /* SCOTCH_DEBUG_ALL */
clockStart (&runtime[0]);
SCOTCH_graphOrderSave (&grafdat, &ordedat, C_filepntrordout); /* Write ordering */
if (flagval & C_FLAGMAPOUT) /* If mapping wanted */
SCOTCH_graphOrderSaveMap (&grafdat, &ordedat, C_filepntrmapout); /* Write mapping */
if (flagval & C_FLAGTREOUT) /* If separator tree wanted */
SCOTCH_graphOrderSaveTree (&grafdat, &ordedat, C_filepntrtreout); /* Write tree */
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\tOrder\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]));
}
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
SCOTCH_graphOrderExit (&grafdat, &ordedat);
SCOTCH_stratExit (&stradat);
SCOTCH_graphExit (&grafdat);
memFree (permtab);
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
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);
}
// Call scotch with options from dictionary.
Foam::label Foam::ptscotchDecomp::decompose
(
const fileName& meshPath,
const List<int>& adjncy,
const List<int>& xadj,
const scalarField& cWeights,
List<int>& finalDecomp
) const
{
if (debug)
{
Pout<< "ptscotchDecomp : entering with xadj:" << xadj.size() << endl;
}
// Dump graph
if (decompositionDict_.found("ptscotchCoeffs"))
{
const dictionary& scotchCoeffs =
decompositionDict_.subDict("ptscotchCoeffs");
if (scotchCoeffs.lookupOrDefault("writeGraph", false))
{
OFstream str
(
meshPath + "_" + Foam::name(Pstream::myProcNo()) + ".dgr"
);
Pout<< "Dumping Scotch graph file to " << str.name() << endl
<< "Use this in combination with dgpart." << endl;
globalIndex globalCells(xadj.size()-1);
// Distributed graph file (.grf)
label version = 2;
str << version << nl;
// Number of files (procglbnbr)
str << Pstream::nProcs();
// My file number (procloc)
str << ' ' << Pstream::myProcNo() << nl;
// Total number of vertices (vertglbnbr)
str << globalCells.size();
// Total number of connections (edgeglbnbr)
str << ' ' << returnReduce(xadj[xadj.size()-1], sumOp<label>())
<< nl;
// Local number of vertices (vertlocnbr)
str << xadj.size()-1;
// Local number of connections (edgelocnbr)
str << ' ' << xadj[xadj.size()-1] << nl;
// Numbering starts from 0
label baseval = 0;
// 100*hasVertlabels+10*hasEdgeWeights+1*hasVertWeighs
str << baseval << ' ' << "000" << nl;
for (label cellI = 0; cellI < xadj.size()-1; cellI++)
{
label start = xadj[cellI];
label end = xadj[cellI+1];
str << end-start;
for (label i = start; i < end; i++)
{
str << ' ' << adjncy[i];
}
str << nl;
}
}
}
// Strategy
// ~~~~~~~~
// Default.
SCOTCH_Strat stradat;
check(SCOTCH_stratInit(&stradat), "SCOTCH_stratInit");
if (decompositionDict_.found("scotchCoeffs"))
{
const dictionary& scotchCoeffs =
decompositionDict_.subDict("scotchCoeffs");
string strategy;
if (scotchCoeffs.readIfPresent("strategy", strategy))
{
if (debug)
{
Info<< "ptscotchDecomp : Using strategy " << strategy << endl;
}
SCOTCH_stratDgraphMap(&stradat, strategy.c_str());
//fprintf(stdout, "S\tStrat=");
//SCOTCH_stratSave(&stradat, stdout);
//fprintf(stdout, "\n");
}
}
// Graph
// ~~~~~
List<int> velotab;
// Check for externally provided cellweights and if so initialise weights
scalar minWeights = gMin(cWeights);
if (cWeights.size() > 0)
{
if (minWeights <= 0)
{
WarningIn
(
"ptscotchDecomp::decompose(..)"
) << "Illegal minimum weight " << minWeights
<< endl;
}
if (cWeights.size() != xadj.size()-1)
{
FatalErrorIn
(
"ptscotchDecomp::decompose(..)"
) << "Number of cell weights " << cWeights.size()
<< " does not equal number of cells " << xadj.size()-1
<< exit(FatalError);
}
// Convert to integers.
velotab.setSize(cWeights.size());
forAll(velotab, i)
{
velotab[i] = int(cWeights[i]/minWeights);
}
}
if (debug)
{
Pout<< "SCOTCH_dgraphInit" << endl;
}
SCOTCH_Dgraph grafdat;
check(SCOTCH_dgraphInit(&grafdat, MPI_COMM_WORLD), "SCOTCH_dgraphInit");
if (debug)
{
Pout<< "SCOTCH_dgraphBuild with:" << nl
<< "xadj.size()-1 : " << xadj.size()-1 << nl
<< "xadj : " << long(xadj.begin()) << nl
<< "velotab : " << long(velotab.begin()) << nl
<< "adjncy.size() : " << adjncy.size() << nl
<< "adjncy : " << long(adjncy.begin()) << nl
<< endl;
}
check
(
SCOTCH_dgraphBuild
(
&grafdat, // grafdat
0, // baseval, c-style numbering
xadj.size()-1, // vertlocnbr, nCells
xadj.size()-1, // vertlocmax
const_cast<SCOTCH_Num*>(xadj.begin()),
// vertloctab, start index per cell into
// adjncy
const_cast<SCOTCH_Num*>(&xadj[1]),// vendloctab, end index ,,
const_cast<SCOTCH_Num*>(velotab.begin()),// veloloctab, vtx weights
NULL, // vlblloctab
adjncy.size(), // edgelocnbr, number of arcs
adjncy.size(), // edgelocsiz
const_cast<SCOTCH_Num*>(adjncy.begin()), // edgeloctab
NULL, // edgegsttab
NULL // edlotab, edge weights
),
"SCOTCH_dgraphBuild"
);
if (debug)
{
Pout<< "SCOTCH_dgraphCheck" << endl;
}
check(SCOTCH_dgraphCheck(&grafdat), "SCOTCH_dgraphCheck");
// Architecture
// ~~~~~~~~~~~~
// (fully connected network topology since using switch)
if (debug)
{
Pout<< "SCOTCH_archInit" << endl;
}
SCOTCH_Arch archdat;
check(SCOTCH_archInit(&archdat), "SCOTCH_archInit");
List<label> processorWeights;
if (decompositionDict_.found("scotchCoeffs"))
{
const dictionary& scotchCoeffs =
decompositionDict_.subDict("scotchCoeffs");
scotchCoeffs.readIfPresent("processorWeights", processorWeights);
}
if (processorWeights.size())
{
if (debug)
{
Info<< "ptscotchDecomp : Using procesor weights "
<< processorWeights
<< endl;
}
check
(
SCOTCH_archCmpltw(&archdat, nProcessors_, processorWeights.begin()),
"SCOTCH_archCmpltw"
);
}
else
{
if (debug)
{
Pout<< "SCOTCH_archCmplt" << endl;
}
check
(
SCOTCH_archCmplt(&archdat, nProcessors_),
"SCOTCH_archCmplt"
);
}
//SCOTCH_Mapping mapdat;
//SCOTCH_dgraphMapInit(&grafdat, &mapdat, &archdat, NULL);
//SCOTCH_dgraphMapCompute(&grafdat, &mapdat, &stradat); /*Perform mapping*/
//SCOTCHdgraphMapExit(&grafdat, &mapdat);
// Hack:switch off fpu error trapping
# ifdef LINUX_GNUC
int oldExcepts = fedisableexcept
(
FE_DIVBYZERO
| FE_INVALID
| FE_OVERFLOW
);
# endif
if (debug)
{
Pout<< "SCOTCH_dgraphMap" << endl;
}
finalDecomp.setSize(xadj.size()-1);
finalDecomp = 0;
check
(
SCOTCH_dgraphMap
(
&grafdat,
&archdat,
&stradat, // const SCOTCH_Strat *
finalDecomp.begin() // parttab
),
"SCOTCH_graphMap"
);
# ifdef LINUX_GNUC
feenableexcept(oldExcepts);
# endif
//finalDecomp.setSize(xadj.size()-1);
//check
//(
// SCOTCH_dgraphPart
// (
// &grafdat,
// nProcessors_, // partnbr
// &stradat, // const SCOTCH_Strat *
// finalDecomp.begin() // parttab
// ),
// "SCOTCH_graphPart"
//);
if (debug)
{
Pout<< "SCOTCH_dgraphExit" << endl;
}
// Release storage for graph
SCOTCH_dgraphExit(&grafdat);
// Release storage for strategy
SCOTCH_stratExit(&stradat);
// Release storage for network topology
SCOTCH_archExit(&archdat);
return 0;
}
bool
ScotchSplitter(unsigned dim,
const int* ptRows, const int* indCols,
unsigned& nbMaxLevels, unsigned minSize,
int* loc2glob, int* glob2loc, int& nbDoms,
int*& ptOnDomains, int*& sizeOfDomains,
bool checkData, const bool verbose, FILE *fp)
{
int ierr;
// check consistency between Scotch and Dissection library
CHECK(sizeof(int) == sizeof(SCOTCH_Num),
"Incompatible integer representation between Scotch and Dissection");
if (verbose) {
int vers, rela, patc;
SCOTCH_version(&vers, &rela, &patc);
diss_printf(verbose, fp, "%s %d : Soctch version : %d.%d.%d\n",
__FILE__, __LINE__, vers, rela, patc);
}
// Allocate and initialize the Scotch graph
SCOTCH_Graph ptGraph;
ierr = SCOTCH_graphInit(&ptGraph);
CHECK(ierr==0,"Fail initializing Scotch graph");
// TRACE("Building Scotch graph\n");
ierr = SCOTCH_graphBuild(&ptGraph,
(SCOTCH_Num)0, // offset,
(SCOTCH_Num)dim,
(const SCOTCH_Num*)ptRows,
(const SCOTCH_Num*)ptRows+1,
NULL, NULL, (SCOTCH_Num)ptRows[dim],
(const SCOTCH_Num*)indCols, NULL);
// if (verbose) {
// fprintf(fp, "%s %d : 1 : ptRows = %p indCols = %p\n",
// __FILE__, __LINE__, (void *)ptRows, (void *)indCols);
// }
CHECK(ierr==0,"Scotch graph building failed !");
if (checkData) {
//TRACE("Check Scotch graph\n");
ierr = SCOTCH_graphCheck(&ptGraph);
if (ierr) {
diss_printf(verbose, fp,
"Failed the checking of the graph : bad data ?\n");
SCOTCH_graphFree(&ptGraph);
return false;
}
}
// Allocate and initialize the strategy wanted for Scotch
// TRACE("Initialize strategy for splitting\n");
SCOTCH_Strat ptStrat;
ierr = SCOTCH_stratInit(&ptStrat);
CHECK(ierr==0,
"Failed initializing Scotch strategy structure");
char *str_Strat = new char[1024];
int nbLvls = std::min(unsigned(nbMaxLevels),
highestbit(unsigned(dim/minSize)));
diss_printf(verbose, fp, "nbLevels = %d\n", nbLvls);
sprintf(str_Strat,"c{rat=0.7,cpr=n{sep=/((levl<%d)|(vert>%d))?m{type=h,rat=0.7,vert=100,low=h{pass=10},asc=b{width=3,bnd=f{bal=0.2},org=h{pass=10}f{bal=0.2}}}|m{type=h,rat=0.7,vert=100,low=h{pass=10},asc=b{width=3,bnd=f{bal=0.2},org=h{pass=10}f{bal=0.2}}};,ole=f{cmin=%d,cmax=%d,frat=0.05},ose=s},unc=n{sep=/(levl<%d)?(m{type=h,rat=0.7,vert=100,low=h{pass=10},asc=b{width=3,bnd=f{bal=0.2},org=h{pass=10}f{bal=0.2}}})|m{type=h,rat=0.7,vert=100,low=h{pass=10},asc=b{width=3,bnd=f{bal=0.2},org=h{pass=10}f{bal=0.2}}};,ole=f{cmin=%d,cmax=%d,frat=0.05},ose=s}}",
nbLvls-1,2*minSize-1,minSize,dim,nbLvls-1,minSize,dim);
// DBG_PRINT("Strategy string : %s\n", str_Strat);
ierr = SCOTCH_stratGraphOrder(&ptStrat, str_Strat);
delete [] str_Strat;
CHECK(ierr==0,
"Failed build graph ordering strategy for Scotch");
// Ordering with nested bisection :
// TRACE("Split the graph\n");
int* rangtab = new int[dim+1];
int* treetab = new int[dim];
int nbSplitDoms;
bool repeat = true;
int lastCompleteLevel;
int *levels, *nbDomsPerLevels;
SCOTCH_randomReset();
while (repeat) {
ierr = SCOTCH_graphOrder(&ptGraph, &ptStrat,
(SCOTCH_Num*)loc2glob,
(SCOTCH_Num*)glob2loc,
(SCOTCH_Num*)&nbSplitDoms,
(SCOTCH_Num*)rangtab,
(SCOTCH_Num*)treetab);
if (ierr) {
diss_printf(verbose, fp, "Failed reordering sparse matrix graph !\n");
SCOTCH_stratExit(&ptStrat);
SCOTCH_graphFree(&ptGraph);
return false;
}
levels = new int[nbSplitDoms];
// int *nbDomsPerLevels;// = new int[nbLvls];
unsigned nbLvlsScotch= compLevelOfDoms(nbSplitDoms, nbLvls, treetab, levels,
nbDomsPerLevels);
/** Search last level where number of domains is a power of two
*/
lastCompleteLevel = 0;
while ((lastCompleteLevel<nbLvlsScotch) &&
((1<<lastCompleteLevel) == nbDomsPerLevels[lastCompleteLevel]) ) {
lastCompleteLevel ++;
}
lastCompleteLevel = std::min(lastCompleteLevel, nbLvls);
nbDoms = (1<<lastCompleteLevel)-1;
// Search where start each domain per bisection level
// and compute the size of each subdomain :
// int indDom = 0;
bool flag_size_check = false;
for (int i = 0; i < nbSplitDoms; i++) {
int sz = 0;
while (levels[i]>=lastCompleteLevel) {
sz += rangtab[i+1]-rangtab[i];
i++;
}
if (sz+rangtab[i+1]-rangtab[i] <= TOO_SMALL) {
flag_size_check = true;
break;
}
//DBG_PRINT("Domain %d begin at %d\n",indDom+1,begDom);
} // loop : i
if (!flag_size_check) {
repeat = false;
break;
}
else {
delete [] levels;
delete [] nbDomsPerLevels;
}
} // while (repeat)
ptOnDomains = new int[nbDoms+1];
sizeOfDomains = new int[nbDoms];
memset(sizeOfDomains, 0, nbDoms*sizeof(int));
int* indDomPerLevel = new int[lastCompleteLevel+1];
memset(indDomPerLevel,0,(lastCompleteLevel+1)*sizeof(int));
int begDom = 0;
for (int i = 0; i < nbSplitDoms; i++) {
int sz = 0;
while (levels[i]>=lastCompleteLevel) {
sz += rangtab[i+1]-rangtab[i];
i++;
}
int indDom = (1<<levels[i])-1+indDomPerLevel[levels[i]];
// DBG_PRINT("level %d : current dom = %d\n", levels[i],indDom+1);
ptOnDomains[indDom] = begDom;
//DBG_PRINT("Domain %d begin at %d\n",indDom+1,begDom);
sizeOfDomains[indDom] = sz+rangtab[i+1]-rangtab[i];
//DBG_PRINT("Domain %d size of %d\n",indDom+1,sizeOfDomains[indDom]);
begDom += sizeOfDomains[indDom];
indDomPerLevel[levels[i]] += 1;
}
diss_printf(verbose, fp, "%s %d : indDomPerlevel[lastCompleteLevel] = %d\n",
__FILE__, __LINE__, indDomPerLevel[lastCompleteLevel]);
ptOnDomains[nbDoms] = dim;
nbMaxLevels = lastCompleteLevel;
delete [] indDomPerLevel;
delete [] nbDomsPerLevels;
delete [] levels;
delete [] treetab;
delete [] rangtab;
// Cleaning all Scotch structures :
SCOTCH_stratExit(&ptStrat);
SCOTCH_graphFree(&ptGraph);
return true;
}
static PetscErrorCode MatPartitioningApply_Scotch(MatPartitioning part, IS * partitioning)
{
PetscErrorCode ierr;
int *parttab, *locals = PETSC_NULL, rank, i, size;
size_t j;
Mat mat = part->adj, matMPI, matSeq;
int nb_locals = mat->rmap->n;
Mat_MPIAdj *adj = (Mat_MPIAdj *) mat->data;
MatPartitioning_Scotch *scotch = (MatPartitioning_Scotch *) part->data;
PetscTruth flg;
#ifdef PETSC_HAVE_UNISTD_H
int fd_stdout, fd_pipe[2], count,err;
#endif
PetscFunctionBegin;
/* check if the matrix is sequential, use MatGetSubMatrices if necessary */
ierr = MPI_Comm_size(((PetscObject)mat)->comm, &size);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject) mat, MATMPIADJ, &flg);CHKERRQ(ierr);
if (size > 1) {
int M, N;
IS isrow, iscol;
Mat *A;
if (flg) {
SETERRQ(0, "Distributed matrix format MPIAdj is not supported for sequential partitioners");
}
PetscPrintf(((PetscObject)part)->comm, "Converting distributed matrix to sequential: this could be a performance loss\n");CHKERRQ(ierr);
ierr = MatGetSize(mat, &M, &N);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF, M, 0, 1, &isrow);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF, N, 0, 1, &iscol);CHKERRQ(ierr);
ierr = MatGetSubMatrices(mat, 1, &isrow, &iscol, MAT_INITIAL_MATRIX, &A);CHKERRQ(ierr);
matSeq = *A;
ierr = PetscFree(A);CHKERRQ(ierr);
ierr = ISDestroy(isrow);CHKERRQ(ierr);
ierr = ISDestroy(iscol);CHKERRQ(ierr);
} else
matSeq = mat;
/* convert the the matrix to MPIADJ type if necessary */
if (!flg) {
ierr = MatConvert(matSeq, MATMPIADJ, MAT_INITIAL_MATRIX, &matMPI);CHKERRQ(ierr);
} else {
matMPI = matSeq;
}
adj = (Mat_MPIAdj *) matMPI->data; /* finaly adj contains adjacency graph */
ierr = MPI_Comm_rank(((PetscObject)part)->comm, &rank);CHKERRQ(ierr);
{
/* definition of Scotch library arguments */
SCOTCH_Strat stratptr; /* scotch strategy */
SCOTCH_Graph grafptr; /* scotch graph */
#if defined(DOES_NOT_COMPILE_DUE_TO_BROKEN_INTERFACE)
int vertnbr = mat->rmap->N; /* number of vertices in full graph */
int *verttab = adj->i; /* start of edge list for each vertex */
int *edgetab = adj->j; /* edge list data */
int edgenbr = adj->nz; /* number of edges */
int *velotab = NULL; /* not used by petsc interface */
int *vlbltab = NULL;
int *edlotab = NULL;
int flagval = 3; /* (cf doc scotch no weight edge & vertices) */
#endif
int baseval = 0; /* 0 for C array indexing */
char strategy[256];
ierr = PetscMalloc((mat->rmap->N) * sizeof(int), &parttab);CHKERRQ(ierr);
/* redirect output to buffer scotch -> mesg_log */
#ifdef PETSC_HAVE_UNISTD_H
fd_stdout = dup(1);
pipe(fd_pipe);
close(1);
dup2(fd_pipe[1], 1);
ierr = PetscMalloc(SIZE_LOG * sizeof(char), &(scotch->mesg_log));CHKERRQ(ierr);
#endif
/* library call */
/* Construction of the scotch graph object */
ierr = SCOTCH_graphInit(&grafptr);
#if defined(DOES_NOT_COMPILE_DUE_TO_BROKEN_INTERFACE)
ierr = SCOTCH_graphBuild((SCOTCH_Graph *) &grafptr,
(const SCOTCH_Num) vertnbr,
(const SCOTCH_Num) verttab,
(const SCOTCH_Num *)velotab,
(const SCOTCH_Num *)vlbltab,
(const SCOTCH_Num *)edgenbr,
(const SCOTCH_Num *)edgetab,
(const SCOTCH_Num) edlotab,
(const SCOTCH_Num *)baseval,
(const SCOTCH_Num *)flagval);CHKERRQ(ierr);
#else
SETERRQ(PETSC_ERR_SUP,"Scotch interface currently broken");
#endif
ierr = SCOTCH_graphCheck(&grafptr);CHKERRQ(ierr);
/* Construction of the strategy */
if (scotch->strategy[0] != 0) {
ierr = PetscStrcpy(strategy, scotch->strategy);CHKERRQ(ierr);
} else {
PetscStrcpy(strategy, "b{strat=");
if (scotch->multilevel) {
/* PetscStrcat(strategy,"m{vert=");
sprintf(strategy+strlen(strategy),"%d",scotch->nbvtxcoarsed);
PetscStrcat(strategy,",asc="); */
sprintf(strategy, "b{strat=m{vert=%d,asc=",
scotch->nbvtxcoarsed);
} else
PetscStrcpy(strategy, "b{strat=");
switch (scotch->global_method) {
case MP_SCOTCH_GREEDY:
PetscStrcat(strategy, "h");
break;
case MP_SCOTCH_GPS:
PetscStrcat(strategy, "g");
break;
case MP_SCOTCH_GR_GPS:
PetscStrcat(strategy, "g|h");
}
switch (scotch->local_method) {
case MP_SCOTCH_KERNIGHAN_LIN:
if (scotch->multilevel)
PetscStrcat(strategy, ",low=f}");
else
PetscStrcat(strategy, " f");
break;
case MP_SCOTCH_NONE:
if (scotch->multilevel)
PetscStrcat(strategy, ",asc=x}");
default:
break;
}
PetscStrcat(strategy, " x}");
}
PetscPrintf(((PetscObject)part)->comm, "strategy=[%s]\n", strategy);
ierr = SCOTCH_stratInit(&stratptr);CHKERRQ(ierr);
/*
TODO: Correct this part
Commented because this doesn't exists anymore
ierr = SCOTCH_stratMap(&stratptr, strategy);CHKERRQ(ierr);
*/
/* check for option mapping */
if (!scotch->map) {
/* ********************************************
* *
* TODO: Correct this part *
* *
* Won't work with this tmp SCOTCH_Strat... *
* *
* I just modified it to make scotch compile, *
* to be able to use PaStiX... *
* *
**********************************************/
#if defined (DOES_NOT_COMPILE_DUE_TO_BROKEN_INTERFACE)
SCOTCH_Strat tmp;
ierr = SCOTCH_graphPart((const SCOTCH_Graph *)&grafptr,
(const SCOTCH_Num) &stratptr,
(const SCOTCH_Strat *)&tmp, /* The Argument changed from scotch 3.04 it was part->n, */
(SCOTCH_Num *) parttab);CHKERRQ(ierr);
#else
SETERRQ(PETSC_ERR_SUP,"Scotch interface currently broken");
#endif
ierr = PetscPrintf(PETSC_COMM_SELF, "Partition simple without mapping\n");
} else {
SCOTCH_Graph grafarch;
SCOTCH_Num *listtab;
SCOTCH_Num listnbr = 0;
SCOTCH_Arch archptr; /* file in scotch architecture format */
SCOTCH_Strat archstrat;
int arch_total_size, *parttab_tmp,err;
int cpt;
char buf[256];
FILE *file1, *file2;
char host_buf[256];
/* generate the graph that represents the arch */
file1 = fopen(scotch->arch, "r");
if (!file1) SETERRQ1(PETSC_ERR_FILE_OPEN, "Scotch: unable to open architecture file %s", scotch->arch);
ierr = SCOTCH_graphInit(&grafarch);CHKERRQ(ierr);
ierr = SCOTCH_graphLoad(&grafarch, file1, baseval, 3);CHKERRQ(ierr);
ierr = SCOTCH_graphCheck(&grafarch);CHKERRQ(ierr);
SCOTCH_graphSize(&grafarch, &arch_total_size, &cpt);
err = fclose(file1);
if (err) SETERRQ(PETSC_ERR_SYS,"fclose() failed on file");
printf("total size = %d\n", arch_total_size);
/* generate the list of nodes currently working */
ierr = PetscGetHostName(host_buf, 256);CHKERRQ(ierr);
ierr = PetscStrlen(host_buf, &j);CHKERRQ(ierr);
file2 = fopen(scotch->host_list, "r");
if (!file2) SETERRQ1(PETSC_ERR_FILE_OPEN, "Scotch: unable to open host list file %s", scotch->host_list);
i = -1;
flg = PETSC_FALSE;
while (!feof(file2) && !flg) {
i++;
fgets(buf, 256, file2);
PetscStrncmp(buf, host_buf, j, &flg);
}
err = fclose(file2);
if (err) SETERRQ(PETSC_ERR_SYS,"fclose() failed on file");
if (!flg) SETERRQ1(PETSC_ERR_LIB, "Scotch: unable to find '%s' in host list file", host_buf);
listnbr = size;
ierr = PetscMalloc(sizeof(SCOTCH_Num) * listnbr, &listtab);CHKERRQ(ierr);
ierr = MPI_Allgather(&i, 1, MPI_INT, listtab, 1, MPI_INT, ((PetscObject)part)->comm);CHKERRQ(ierr);
printf("listnbr = %d, listtab = ", listnbr);
for (i = 0; i < listnbr; i++)
printf("%d ", listtab[i]);
printf("\n");
err = fflush(stdout);
if (err) SETERRQ(PETSC_ERR_SYS,"fflush() failed on file");
ierr = SCOTCH_stratInit(&archstrat);CHKERRQ(ierr);
/**************************************************************
* *
* TODO: Correct this part *
* *
* Commented because this doesn't exists anymore *
* *
* ierr = SCOTCH_stratBipart(&archstrat, "fx");CHKERRQ(ierr); *
**************************************************************/
ierr = SCOTCH_archInit(&archptr);CHKERRQ(ierr);
ierr = SCOTCH_archBuild(&archptr, &grafarch, listnbr, listtab,
&archstrat);CHKERRQ(ierr);
ierr = PetscMalloc((mat->rmap->N) * sizeof(int), &parttab_tmp);CHKERRQ(ierr);
/************************************************************************************
* *
* TODO: Correct this part *
* *
* Commented because this doesn't exists anymore *
* *
* ierr = SCOTCH_mapInit(&mappptr, &grafptr, &archptr, parttab_tmp);CHKERRQ(ierr); *
* *
* ierr = SCOTCH_mapCompute(&mappptr, &stratptr);CHKERRQ(ierr); *
* *
* ierr = SCOTCH_mapView(&mappptr, stdout);CHKERRQ(ierr); *
************************************************************************************/
/* now we have to set in the real parttab at the good place */
/* because the ranks order are different than position in */
/* the arch graph */
for (i = 0; i < mat->rmap->N; i++) {
parttab[i] = parttab_tmp[i];
}
ierr = PetscFree(listtab);CHKERRQ(ierr);
SCOTCH_archExit(&archptr);
/*************************************************
* TODO: Correct this part *
* *
* Commented because this doesn't exists anymore *
* SCOTCH_mapExit(&mappptr); *
*************************************************/
SCOTCH_stratExit(&archstrat);
}
/* dump to mesg_log... */
#ifdef PETSC_HAVE_UNISTD_H
err = fflush(stdout);
if (err) SETERRQ(PETSC_ERR_SYS,"fflush() failed on stdout");
count = read(fd_pipe[0], scotch->mesg_log, (SIZE_LOG - 1) * sizeof(char));
if (count < 0)
count = 0;
scotch->mesg_log[count] = 0;
close(1);
dup2(fd_stdout, 1);
close(fd_stdout);
close(fd_pipe[0]);
close(fd_pipe[1]);
#endif
SCOTCH_graphExit(&grafptr);
SCOTCH_stratExit(&stratptr);
}
if (ierr)
SETERRQ(PETSC_ERR_LIB, scotch->mesg_log);
/* Creation of the index set */
ierr = MPI_Comm_rank(((PetscObject)part)->comm, &rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(((PetscObject)part)->comm, &size);CHKERRQ(ierr);
nb_locals = mat->rmap->N / size;
locals = parttab + rank * nb_locals;
if (rank < mat->rmap->N % size) {
nb_locals++;
locals += rank;
} else
locals += mat->rmap->N % size;
ierr = ISCreateGeneral(((PetscObject)part)->comm, nb_locals, locals, partitioning);CHKERRQ(ierr);
/* destroying old objects */
ierr = PetscFree(parttab);CHKERRQ(ierr);
if (matSeq != mat) {
ierr = MatDestroy(matSeq);CHKERRQ(ierr);
}
if (matMPI != mat) {
ierr = MatDestroy(matMPI);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static
void run_scotch( Container &c,
MapContainer &mapping,
const std::size_t cores,
weight_function_t weight_func,
void *weight )
{
#if 0
static_assert( std::is_signed<
std::remove_reference< decltype( c.end() ) >::type >::value,
"Container must have signed types so that -1 may signify no mapping" );
#endif
raftgraph_t raft_graph;
get_graph_info( c,
raft_graph,
weight_func,
nullptr );
SCOTCH_Graph graph;
if( SCOTCH_graphInit( &graph ) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Failed to initialize graph!!\n";
exit( EXIT_FAILURE );
}
auto table( raft_graph.getScotchTables() );
if( SCOTCH_graphBuild(
&graph /** graph ptr **/,
0 /** base value **/,
table.num_vertices /** vertex nmbr (zero indexed) **/,
table.vtable /** vertex tab **/,
&table.vtable[ 1 ] /** vendtab **/,
nullptr /** velotab **/,
nullptr /** vlbltab **/,
table.num_edges /** edge number **/,
table.etable /** edge tab **/,
table.eweight /** edlotab **/
) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Failed to build graph\n";
exit( EXIT_FAILURE );
}
if( SCOTCH_graphCheck( &graph ) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Graph is inconsistent\n";
std::remove_reference< decltype( table ) >::type::print( std::cerr, table );
std::cerr << "\n";
raft_graph.print( std::cerr );
exit( EXIT_FAILURE );
}
/** TODO, we can do much more with this arch file **/
SCOTCH_Arch archdat;
if( SCOTCH_archInit( &archdat ) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Architecture initialization failed\n";
exit( EXIT_FAILURE );
}
/** core are equal **/
if( SCOTCH_archCmplt( &archdat, cores /** num cores **/) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Failed to create architecture file\n";
exit( EXIT_FAILURE );
}
/** strategy **/
SCOTCH_Strat stradat;
if( SCOTCH_stratInit( &stradat ) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Failed to init strategy!!\n";
exit( EXIT_FAILURE );
}
/** build recursive strategy **/
if( SCOTCH_stratGraphClusterBuild(
&stradat,
SCOTCH_STRATSPEED,
cores,
.75,
.01) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Failed to map strategy graph!!\n";
exit( EXIT_FAILURE );
}
if( SCOTCH_graphMap(
&graph /** graph ptr **/,
&archdat,
&stradat,
table.partition /** parttab **/
) != 0 )
{
/** TODO, add RaftLib Exception **/
std::cerr << "Failed to map!!\n";
exit( EXIT_FAILURE );
}
/**
* first case is for if we've mapped all vertices,
* second is for when some of the kernels are innactive
* in which case the number of vertices in the
* table will be less than the size of c in which case
* we need to get which vertices (the actual number id
* from the application) are mapped and to where, the
* returned table in mapping must include even the
* vertices that aren't active (indicated by a -1) so
* that the returning loop can be as simple as possible
*/
if( c.size() == table.num_vertices )
{
/** copy mapping **/
for( auto i( 0 ); i < table.num_vertices; i++ )
{
mapping.emplace_back( table.partition[ i ] );
}
}
else
{
const auto &vmapping( raft_graph.getVertexNumbersAtIndicies() );
auto it_map_index( vmapping.cbegin() );
auto table_index( 0 );
const auto size( c.size() );
for( auto i( 0 ); i < size; i++ )
{
if( i == (*it_map_index) && it_map_index != vmapping.cend() )
{
mapping.emplace_back( table.partition[ table_index++ ] );
++it_map_index;
}
else
{
mapping.emplace_back( -1 );
}
}
}
/** call exit graph **/
SCOTCH_graphExit( &graph );
SCOTCH_stratExit( &stradat );
SCOTCH_archExit ( &archdat );
return;
}
/* Internal function : biPartBoxCompute
* it computes a new numbering of graph vertices, using a bipartitioning.
*
* - graf : the input graph
* - vertNbr : the number of vertices
* - boxVertNbr : the number of vertices of each box
* - permVrtTab : the new numbering
*
* returning 0 if OK, 1 else
*/
int biPartBoxCompute(SCOTCH_Graph graf, int vertNbr, int boxVertNbr, SCOTCH_Num *permVrtTab) {
int boxNbr, vertIdx, boxIdx;
SCOTCH_Num tmp, tmp2, *partTab, *partNumTab, *partPrmTab;
SCOTCH_Strat strat ;
/* Computing the number of boxes */
boxNbr = vertNbr / boxVertNbr;
if (boxNbr * boxVertNbr != vertNbr) {
boxNbr = boxNbr + 1;
}
/* Initializing SCOTCH functions */
CHECK_SCOTCH(SCOTCH_stratInit(&strat), "scotch_stratInit", 0) ;
CHECK_SCOTCH(SCOTCH_stratGraphMap(&strat, "r{job=t,map=t,poli=S,sep=m{type=h,vert=80,low=h{pass=10}f{bal=0.005,move=0},asc=b{bnd=f{bal=0.05,move=0},org=f{bal=0.05,move=0}}}|m{type=h,vert=80,low=h{pass=10}f{bal=0.005,move=0},asc=b{bnd=f{bal=0.05,move=0},org=f{bal=0.05,move=0}}}}"), "scotch_stratGraphMap", 0) ;
partTab = (SCOTCH_Num *)M_calloc(vertNbr, sizeof(SCOTCH_Num), "boxCompute");
/* Partionning the graph */
CHECK_SCOTCH(SCOTCH_graphPart(&graf, boxNbr, &strat, partTab), "scotch_graphPart", 0);
partNumTab = (SCOTCH_Num *)M_calloc(boxNbr, sizeof(SCOTCH_Num), "boxCompute");
if (!memset(partNumTab, 0, boxNbr*sizeof(SCOTCH_Num))) {
perror("memset");
return 0;
}
/* Computing the number of elements of each box */
for( vertIdx = 0 ; vertIdx< vertNbr ;vertIdx++)
partNumTab[partTab[vertIdx]] += 1;
/* partition permutation tabular */
partPrmTab = (SCOTCH_Num *)M_calloc(vertNbr + 1, sizeof(SCOTCH_Num), "boxCompute");
/* Copying the previous tabular in order to have the index of the first
* element of each box
* */
tmp = partNumTab[0];
partNumTab[0] = 0;
for(boxIdx = 1; boxIdx < boxNbr ; boxIdx++) {
tmp2 = partNumTab[boxIdx];
partNumTab[boxIdx] = partNumTab[boxIdx-1] + tmp;
tmp = tmp2;
}
/* partPrmTab is built such as each vertex belongs to his box */
for( vertIdx = 0;vertIdx< vertNbr;vertIdx++)
partPrmTab[partNumTab[partTab[vertIdx]]++] = vertIdx;
/* Infering the new numbering */
for (vertIdx = 0; vertIdx < vertNbr ; vertIdx++)
permVrtTab[partPrmTab[vertIdx] + 1] = vertIdx + 1;
M_free(partTab);
M_free(partNumTab);
M_free(partPrmTab);
SCOTCH_stratExit(&strat) ;
return 0;
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Dgraph grafdat;
SCOTCH_Dordering ordedat;
SCOTCH_Strat stradat;
SCOTCH_Num straval;
char * straptr;
int flagval;
int procglbnbr;
int proclocnum;
int protglbnum; /* Root process */
Clock runtime[2]; /* Timing variables */
double reduloctab[12]; /* 3 * (min, max, sum) */
double reduglbtab[12];
MPI_Datatype redutype;
MPI_Op reduop;
int i, j;
#ifdef SCOTCH_PTHREAD
int thrdlvlreqval;
int thrdlvlproval;
#endif /* SCOTCH_PTHREAD */
errorProg ("dgord");
#ifdef SCOTCH_PTHREAD
thrdlvlreqval = MPI_THREAD_MULTIPLE;
if (MPI_Init_thread (&argc, &argv, thrdlvlreqval, &thrdlvlproval) != MPI_SUCCESS)
errorPrint ("main: Cannot initialize (1)");
if (thrdlvlreqval > thrdlvlproval)
errorPrint ("main: MPI implementation is not thread-safe: recompile without SCOTCH_PTHREAD");
#else /* SCOTCH_PTHREAD */
if (MPI_Init (&argc, &argv) != MPI_SUCCESS)
errorPrint ("main: Cannot initialize (2)");
#endif /* SCOTCH_PTHREAD */
MPI_Comm_size (MPI_COMM_WORLD, &procglbnbr); /* Get communicator data */
MPI_Comm_rank (MPI_COMM_WORLD, &proclocnum);
protglbnum = 0; /* Assume root process is process 0 */
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
SCOTCH_randomProc (proclocnum); /* Record process number to initialize pseudo-random seed */
flagval = C_FLAGNONE; /* Default behavior */
straval = 0; /* No strategy flags */
straptr = NULL;
SCOTCH_stratInit (&stradat);
fileBlockInit (C_fileTab, C_FILENBR); /* Set default stream pointers */
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_fileNum < C_FILEARGNBR) /* File name has been given */
fileBlockName (C_fileTab, C_fileNum ++) = 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_FLAGBLOCK;
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;
case 'X' :
case 'x' :
straval |= SCOTCH_STRATSCALABILITY;
break;
default :
errorPrint ("main: invalid strategy selection option '%c'", argv[i][j]);
}
}
break;
#ifdef SCOTCH_DEBUG_ALL
case 'D' :
case 'd' :
flagval |= C_FLAGDEBUG;
break;
#endif /* SCOTCH_DEBUG_ALL */
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'M' : /* Output separator mapping */
case 'm' :
flagval |= C_FLAGMAPOUT;
if (argv[i][2] != '\0')
C_filenamemapout = &argv[i][2];
break;
case 'O' : /* Ordering strategy */
case 'o' :
straptr = &argv[i][2];
SCOTCH_stratExit (&stradat);
SCOTCH_stratInit (&stradat);
SCOTCH_stratDgraphOrder (&stradat, straptr);
break;
case 'R' : /* Root process (if necessary) */
case 'r' :
protglbnum = atoi (&argv[i][2]);
if ((protglbnum < 0) ||
(protglbnum >= procglbnbr) ||
((protglbnum == 0) && (argv[i][2] != '0')))
errorPrint ("main: invalid root process number");
break;
case 'T' : /* Output separator tree */
case 't' :
flagval |= C_FLAGTREOUT;
if (argv[i][2] != '\0')
C_filenametreout = &argv[i][2];
break;
case 'V' :
fprintf (stderr, "dgord, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 2007-2012,2014 IPB, Universite de Bordeaux, 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 'A' :
case 'a' :
#ifdef COMMON_MEMORY_TRACE
flagval |= C_FLAGVERBMEM;
#else /* COMMON_MEMORY_TRACE */
errorPrint ("main: not compiled with COMMON_MEMORY_TRACE");
#endif /* COMMON_MEMORY_TRACE */
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]);
}
}
}
#ifdef SCOTCH_DEBUG_ALL
if ((flagval & C_FLAGDEBUG) != 0) {
fprintf (stderr, "Proc %4d of %d, pid %d\n", proclocnum, procglbnbr, getpid ());
if (proclocnum == protglbnum) { /* Synchronize on keybord input */
char c;
printf ("Waiting for key press...\n");
scanf ("%c", &c);
}
MPI_Barrier (MPI_COMM_WORLD);
}
#endif /* SCOTCH_DEBUG_ALL */
fileBlockOpenDist (C_fileTab, C_FILENBR, procglbnbr, proclocnum, protglbnum); /* Open all files */
clockInit (&runtime[0]);
clockStart (&runtime[0]);
SCOTCH_dgraphInit (&grafdat, MPI_COMM_WORLD);
SCOTCH_dgraphLoad (&grafdat, C_filepntrsrcinp, -1, 0);
if (straval != 0) {
if (straptr != NULL)
errorPrint ("main: options '-c' and '-o' are exclusive");
SCOTCH_stratDgraphOrderBuild (&stradat, straval, (SCOTCH_Num) procglbnbr, 0, 0.2);
}
clockStop (&runtime[0]); /* Get input time */
clockInit (&runtime[1]);
#ifdef SCOTCH_DEBUG_ALL
if ((flagval & C_FLAGDEBUG) != 0)
MPI_Barrier (MPI_COMM_WORLD);
#endif /* SCOTCH_DEBUG_ALL */
clockStart (&runtime[1]);
SCOTCH_dgraphGhst (&grafdat); /* Compute it once for good */
SCOTCH_dgraphOrderInit (&grafdat, &ordedat);
SCOTCH_dgraphOrderCompute (&grafdat, &ordedat, &stradat);
clockStop (&runtime[1]); /* Get ordering time */
#ifdef SCOTCH_DEBUG_ALL
if ((flagval & C_FLAGDEBUG) != 0)
MPI_Barrier (MPI_COMM_WORLD);
#endif /* SCOTCH_DEBUG_ALL */
clockStart (&runtime[0]);
if (proclocnum == protglbnum) {
if ((flagval & C_FLAGBLOCK) == 0)
SCOTCH_dgraphOrderSave (&grafdat, &ordedat, C_filepntrordout);
else
SCOTCH_dgraphOrderSaveBlock (&grafdat, &ordedat, C_filepntrordout);
if ((flagval & C_FLAGMAPOUT) != 0) /* If mapping wanted */
SCOTCH_dgraphOrderSaveMap (&grafdat, &ordedat, C_filepntrmapout); /* Write mapping */
if ((flagval & C_FLAGTREOUT) != 0) /* If separator tree wanted */
SCOTCH_dgraphOrderSaveTree (&grafdat, &ordedat, C_filepntrtreout); /* Write tree */
}
else {
if ((flagval & C_FLAGBLOCK) == 0)
SCOTCH_dgraphOrderSave (&grafdat, &ordedat, NULL);
else
SCOTCH_dgraphOrderSaveBlock (&grafdat, &ordedat, NULL);
if ((flagval & C_FLAGMAPOUT) != 0)
SCOTCH_dgraphOrderSaveMap (&grafdat, &ordedat, NULL);
if ((flagval & C_FLAGTREOUT) != 0)
SCOTCH_dgraphOrderSaveTree (&grafdat, &ordedat, NULL);
}
clockStop (&runtime[0]);
#ifdef SCOTCH_DEBUG_ALL
if ((flagval & C_FLAGDEBUG) != 0)
MPI_Barrier (MPI_COMM_WORLD);
#endif /* SCOTCH_DEBUG_ALL */
MPI_Type_contiguous (3, MPI_DOUBLE, &redutype);
MPI_Type_commit (&redutype);
MPI_Op_create ((MPI_User_function *) dgordStatReduceOp, 1, &reduop);
if ((flagval & C_FLAGVERBTIM) != 0) {
reduloctab[0] =
reduloctab[1] =
reduloctab[2] = (double) clockVal (&runtime[1]);
reduloctab[3] =
reduloctab[4] =
reduloctab[5] = (double) clockVal (&runtime[0]);
reduloctab[6] =
reduloctab[7] =
reduloctab[8] = reduloctab[0] + reduloctab[3];
MPI_Allreduce (&reduloctab[0], &reduglbtab[0], 3, redutype, reduop, MPI_COMM_WORLD);
}
#ifdef COMMON_MEMORY_TRACE
if ((flagval & C_FLAGVERBMEM) != 0) {
reduloctab[9] =
reduloctab[10] =
reduloctab[11] = (double) memMax ();
MPI_Allreduce (&reduloctab[9], &reduglbtab[9], 1, redutype, reduop, MPI_COMM_WORLD);
}
#endif /* COMMON_MEMORY_TRACE */
MPI_Op_free (&reduop);
MPI_Type_free (&redutype);
if (C_filepntrlogout != NULL) {
if ((flagval & C_FLAGVERBSTR) != 0) {
fprintf (C_filepntrlogout, "S\tStrat=");
SCOTCH_stratSave (&stradat, C_filepntrlogout);
putc ('\n', C_filepntrlogout);
}
if ((flagval & C_FLAGVERBTIM) != 0) {
fprintf (C_filepntrlogout, "T\tOrder\tmin=%g\tmax=%g\tavg=%g\nT\tI/O\tmin=%g\tmax=%g\tavg=%g\nT\tTotal\tmin=%g\tmax=%g\tavg=%g\n",
reduglbtab[0], reduglbtab[1], reduglbtab[2] / (double) procglbnbr,
reduglbtab[3], reduglbtab[4], reduglbtab[5] / (double) procglbnbr,
reduglbtab[6], reduglbtab[7], reduglbtab[8] / (double) procglbnbr);
}
#ifdef COMMON_MEMORY_TRACE
if ((flagval & C_FLAGVERBMEM) != 0)
fprintf (C_filepntrlogout, "A\tMemory\tmin=%g\tmax=%g\tavg=%g\n",
reduglbtab[9], reduglbtab[10], reduglbtab[11] / (double) procglbnbr);
#endif /* COMMON_MEMORY_TRACE */
}
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
SCOTCH_dgraphOrderExit (&grafdat, &ordedat);
SCOTCH_dgraphExit (&grafdat);
SCOTCH_stratExit (&stradat);
MPI_Finalize ();
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
void computeOrdering(const ordinal_type treecut = 0) {
int ierr = 0;
// pointers for global graph ordering
ordinal_type *perm = _perm.ptr_on_device();
ordinal_type *peri = _peri.ptr_on_device();
ordinal_type *range = _range.ptr_on_device();
ordinal_type *tree = _tree.ptr_on_device();
{
// set desired tree level
if (_strat & SCOTCH_STRATLEVELMAX ||
_strat & SCOTCH_STRATLEVELMIN) {
TACHO_TEST_FOR_ABORT(_level == 0, "SCOTCH_STRATLEVEL(MIN/MAX) is used but level is not specified");
}
const int level = Util::max(1, _level-treecut);
SCOTCH_Strat stradat;
SCOTCH_Num straval = _strat;
ierr = SCOTCH_stratInit(&stradat);
TACHO_TEST_FOR_ABORT(ierr, "Failed in SCOTCH_stratInit");
// if both are zero, do not build strategy
if (_strat || _level) {
if (_verbose)
std::cout << "GraphTools_Scotch:: User provide a strategy and/or level" << std::endl
<< " strategy = " << _strat << ", level = " << _level << ", treecut = " << treecut << std::endl
<< " strategy & SCOTCH_STRATLEVELMAX = " << (_strat & SCOTCH_STRATLEVELMAX) << std::endl
<< " strategy & SCOTCH_STRATLEVELMIN = " << (_strat & SCOTCH_STRATLEVELMIN) << std::endl
<< " strategy & SCOTCH_STRATLEAFSIMPLE = " << (_strat & SCOTCH_STRATLEAFSIMPLE) << std::endl
<< " strategy & SCOTCH_STRATSEPASIMPLE = " << (_strat & SCOTCH_STRATSEPASIMPLE) << std::endl
<< std::endl;
ierr = SCOTCH_stratGraphOrderBuild(&stradat, straval, level, 0.2);
TACHO_TEST_FOR_ABORT(ierr, "Failed in SCOTCH_stratGraphOrderBuild");
}
ierr = SCOTCH_graphOrder(&_graph,
&stradat,
perm,
peri,
&_cblk,
range,
tree);
TACHO_TEST_FOR_ABORT(ierr, "Failed in SCOTCH_graphOrder");
SCOTCH_stratExit(&stradat);
}
{
ordinal_type nroot = 0;
for (ordinal_type i=0; i<_cblk; ++i)
nroot += (_tree[i] == -1);
if (nroot > 1) {
if (_verbose)
std::cout << "GraphTools_Scotch:: # of roots " << nroot << std::endl
<< " a fake root is created to complete the tree" << std::endl
<< std::endl;
_tree [_cblk] = -1; // dummy root
_range[_cblk+1] = _range[_cblk]; // zero range for the dummy root
for (ordinal_type i=0; i<_cblk; ++i)
if (_tree[i] == -1) // multiple roots becomes children of the dummy root
_tree[i] = (_cblk+1);
++_cblk; // include the dummy root
}
}
_is_ordered = true;
//std::cout << "SCOTCH level = " << level << std::endl;
//std::cout << "Range Tree " << std::endl;
//for (int i=0;i<_cblk;++i)
// std::cout << _range[i] << " :: " << i << " " << _tree[i] << std::endl;
}
void AlgPTScotch(
const RCP<const Environment> &env, // parameters & app comm
const RCP<const Comm<int> > &problemComm, // problem comm
#ifdef HAVE_ZOLTAN2_MPI
MPI_Comm mpicomm,
#endif
const RCP<GraphModel<typename Adapter::base_adapter_t> > &model, // the graph
RCP<PartitioningSolution<Adapter> > &solution
)
{
HELLO;
typedef typename Adapter::lno_t lno_t;
typedef typename Adapter::gno_t gno_t;
typedef typename Adapter::scalar_t scalar_t;
int ierr = 0;
size_t numGlobalParts = solution->getTargetGlobalNumberOfParts();
SCOTCH_Num partnbr;
SCOTCH_Num_Traits<size_t>::ASSIGN_TO_SCOTCH_NUM(partnbr, numGlobalParts, env);
#ifdef HAVE_ZOLTAN2_MPI
const SCOTCH_Num baseval = 0; // Base value for array indexing.
// GraphModel returns GNOs from base 0.
SCOTCH_Strat stratstr; // Strategy string
// TODO: Set from parameters
SCOTCH_stratInit(&stratstr);
// Allocate & initialize PTScotch data structure.
SCOTCH_Dgraph *gr = SCOTCH_dgraphAlloc(); // Scotch distributed graph
ierr = SCOTCH_dgraphInit(gr, mpicomm);
env->globalInputAssertion(__FILE__, __LINE__, "SCOTCH_dgraphInit",
!ierr, BASIC_ASSERTION, problemComm);
// Get vertex info
ArrayView<const gno_t> vtxID;
ArrayView<StridedData<lno_t, scalar_t> > xyz;
ArrayView<StridedData<lno_t, scalar_t> > vtxWt;
size_t nVtx = model->getVertexList(vtxID, xyz, vtxWt);
SCOTCH_Num vertlocnbr;
SCOTCH_Num_Traits<size_t>::ASSIGN_TO_SCOTCH_NUM(vertlocnbr, nVtx, env);
SCOTCH_Num vertlocmax = vertlocnbr; // Assumes no holes in global nums.
// Get edge info
ArrayView<const gno_t> edgeIds;
ArrayView<const int> procIds;
ArrayView<const lno_t> offsets;
ArrayView<StridedData<lno_t, scalar_t> > ewgts;
size_t nEdges = model->getEdgeList(edgeIds, procIds, offsets, ewgts);
SCOTCH_Num edgelocnbr;
SCOTCH_Num_Traits<size_t>::ASSIGN_TO_SCOTCH_NUM(edgelocnbr, nEdges, env);
const SCOTCH_Num edgelocsize = edgelocnbr; // Assumes adj array is compact.
SCOTCH_Num *vertloctab; // starting adj/vtx
SCOTCH_Num_Traits<lno_t>::ASSIGN_SCOTCH_NUM_ARRAY(&vertloctab, offsets, env);
SCOTCH_Num *edgeloctab; // adjacencies
SCOTCH_Num_Traits<gno_t>::ASSIGN_SCOTCH_NUM_ARRAY(&edgeloctab, edgeIds, env);
// We don't use these arrays, but we need them as arguments to Scotch.
SCOTCH_Num *vendloctab = NULL; // Assume consecutive storage for adj
SCOTCH_Num *vlblloctab = NULL; // Vertex label array
SCOTCH_Num *edgegsttab = NULL; // Array for ghost vertices
// Get weight info.
// TODO: Actually get the weights; for now, not using weights.
SCOTCH_Num *veloloctab = NULL; // Vertex weights
SCOTCH_Num *edloloctab = NULL; // Edge weights
//TODO int vwtdim = model->getVertexWeightDim();
//TODO int ewtdim = model->getEdgeWeightDim();
//TODO if (vwtdim) veloloctab = new SCOTCH_Num[nVtx];
//TODO if (ewtdim) edloloctab = new SCOTCH_Num[nEdges];
//TODO scale weights to SCOTCH_Nums.
// Build PTScotch distributed data structure
ierr = SCOTCH_dgraphBuild(gr, baseval, vertlocnbr, vertlocmax,
vertloctab, vendloctab, veloloctab, vlblloctab,
edgelocnbr, edgelocsize,
edgeloctab, edgegsttab, edloloctab);
env->globalInputAssertion(__FILE__, __LINE__, "SCOTCH_dgraphBuild",
!ierr, BASIC_ASSERTION, problemComm);
// Create array for Scotch to return results in.
ArrayRCP<partId_t> partList(new partId_t [nVtx], 0, nVtx,true);
SCOTCH_Num *partloctab = NULL;
if (nVtx && (sizeof(SCOTCH_Num) == sizeof(partId_t))) {
// Can write directly into the solution's memory
partloctab = (SCOTCH_Num *) partList.getRawPtr();
}
else {
// Can't use solution memory directly; will have to copy later.
// Note: Scotch does not like NULL arrays, so add 1 to always have non-null.
// ParMETIS has this same "feature." See Zoltan bug 4299.
partloctab = new SCOTCH_Num[nVtx+1];
}
// Call partitioning; result returned in partloctab.
// TODO: Use SCOTCH_dgraphMap so can include a machine model in partitioning
ierr = SCOTCH_dgraphPart(gr, partnbr, &stratstr, partloctab);
env->globalInputAssertion(__FILE__, __LINE__, "SCOTCH_dgraphPart",
!ierr, BASIC_ASSERTION, problemComm);
// TODO - metrics
#ifdef SHOW_ZOLTAN2_SCOTCH_MEMORY
int me = env->comm_->getRank();
#endif
#ifdef HAVE_SCOTCH_ZOLTAN2_GETMEMORYMAX
if (me == 0){
size_t scotchBytes = SCOTCH_getMemoryMax();
std::cout << "Rank " << me << ": Maximum bytes used by Scotch: ";
std::cout << scotchBytes << std::endl;
}
#endif
// Clean up PTScotch
SCOTCH_dgraphExit(gr);
delete gr;
SCOTCH_stratExit(&stratstr);
// Load answer into the solution.
if ((sizeof(SCOTCH_Num) != sizeof(partId_t)) || (nVtx == 0)) {
for (size_t i = 0; i < nVtx; i++) partList[i] = partloctab[i];
delete [] partloctab;
}
ArrayRCP<const gno_t> gnos = arcpFromArrayView(vtxID);
solution->setParts(gnos, partList, true);
env->memory("Zoltan2-Scotch: After creating solution");
//if (me == 0) cout << " done." << endl;
// Clean up Zoltan2
//TODO if (vwtdim) delete [] velotab;
//TODO if (ewtdim) delete [] edlotab;
// Clean up copies made due to differing data sizes.
SCOTCH_Num_Traits<lno_t>::DELETE_SCOTCH_NUM_ARRAY(&vertloctab);
SCOTCH_Num_Traits<gno_t>::DELETE_SCOTCH_NUM_ARRAY(&edgeloctab);
#else // DO NOT HAVE_MPI
// TODO: Handle serial case with calls to Scotch.
// TODO: For now, assign everything to rank 0 and assume only one part.
// TODO: Can probably use the code above for loading solution,
// TODO: instead of duplicating it here.
// TODO
// TODO: Actual logic should call Scotch when number of processes == 1.
ArrayView<const gno_t> vtxID;
ArrayView<StridedData<lno_t, scalar_t> > xyz;
ArrayView<StridedData<lno_t, scalar_t> > vtxWt;
size_t nVtx = model->getVertexList(vtxID, xyz, vtxWt);
for (size_t i = 0; i < nVtx; i++) partList[i] = 0;
#endif // DO NOT HAVE_MPI
}
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;
}
int
main (
int argc,
char * argv[])
{
FILE * fileptr;
SCOTCH_Graph grafdat;
SCOTCH_Ordering ordedat;
SCOTCH_Strat stradat;
SCOTCH_Num baseval;
SCOTCH_Num vertnbr;
SCOTCH_Num vertnum;
SCOTCH_Num listnbr;
SCOTCH_Num listnum;
SCOTCH_Num * listtab;
SCOTCH_errorProg (argv[0]);
if (SCOTCH_graphInit (&grafdat) != 0) { /* Initialize source graph */
SCOTCH_errorPrint ("main: cannot initialize graph");
return (1);
}
if ((fileptr = fopen (argv[1], "r")) == NULL) {
SCOTCH_errorPrint ("main: cannot open file (1)");
return (1);
}
if (SCOTCH_graphLoad (&grafdat, fileptr, -1, 0) != 0) { /* Read source graph */
SCOTCH_errorPrint ("main: cannot load graph");
return (1);
}
fclose (fileptr);
SCOTCH_graphData (&grafdat, &baseval, &vertnbr, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
listnbr = (vertnbr + 1) / 2; /* Only keep half of the vertices in induced graph */
if ((listtab = malloc (listnbr * sizeof (SCOTCH_Num))) == NULL) {
SCOTCH_errorPrint ("main: out of memory (1)");
return (1);
}
for (listnum = 0, vertnum = baseval + (listnbr / 4); /* Keep only middle half of the vertices */
listnum < listnbr; listnum ++, vertnum ++)
listtab[listnum] = vertnum;
if ((fileptr = tmpfile ()) == NULL) { /* Open temporary file for resulting output */
SCOTCH_errorPrint ("main: cannot open file (2)");
return (1);
}
if (SCOTCH_stratInit (&stradat) != 0) { /* Initialize ordering strategy */
SCOTCH_errorPrint ("main: cannot initialize strategy");
return (1);
}
if (SCOTCH_graphOrderInit (&grafdat, &ordedat, NULL, NULL, NULL, NULL, NULL) != 0) { /* Initialize ordering */
SCOTCH_errorPrint ("main: cannot initialize ordering (1)");
return (1);
}
if (SCOTCH_graphOrderCompute (&grafdat, &ordedat, &stradat) != 0) {
SCOTCH_errorPrint ("main: cannot order graph");
return (1);
}
if (SCOTCH_graphOrderCheck (&grafdat, &ordedat) != 0) {
SCOTCH_errorPrint ("main: invalid ordering (1)");
return (1);
}
SCOTCH_graphOrderSave (&grafdat, &ordedat, fileptr); /* Test ordering data output routines */
SCOTCH_graphOrderSaveMap (&grafdat, &ordedat, fileptr);
SCOTCH_graphOrderSaveTree (&grafdat, &ordedat, fileptr);
SCOTCH_graphOrderExit (&grafdat, &ordedat); /* Free computed ordering */
if (SCOTCH_graphOrderInit (&grafdat, &ordedat, NULL, NULL, NULL, NULL, NULL) != 0) { /* Initialize ordering again */
SCOTCH_errorPrint ("main: cannot initialize ordering (2)");
return (1);
}
if (SCOTCH_graphOrderComputeList (&grafdat, &ordedat, listnbr, listtab, &stradat) != 0) {
SCOTCH_errorPrint ("main: cannot order induced graph");
return (1);
}
if (SCOTCH_graphOrderCheck (&grafdat, &ordedat) != 0) {
SCOTCH_errorPrint ("main: invalid ordering (2)");
return (1);
}
SCOTCH_graphOrderSave (&grafdat, &ordedat, fileptr); /* Test ordering data output routines */
SCOTCH_graphOrderSaveMap (&grafdat, &ordedat, fileptr);
SCOTCH_graphOrderSaveTree (&grafdat, &ordedat, fileptr);
free (listtab);
SCOTCH_stratExit (&stradat);
SCOTCH_graphOrderExit (&grafdat, &ordedat);
SCOTCH_graphExit (&grafdat);
return (0);
}
// Call scotch with options from dictionary.
Foam::label Foam::scotchDecomp::decompose
(
const List<int>& adjncy,
const List<int>& xadj,
const scalarField& cWeights,
List<int>& finalDecomp
)
{
// Dump graph
if (decompositionDict_.found("scotchCoeffs"))
{
const dictionary& scotchCoeffs =
decompositionDict_.subDict("scotchCoeffs");
if (scotchCoeffs.found("writeGraph"))
{
Switch writeGraph(scotchCoeffs.lookup("writeGraph"));
if (writeGraph)
{
OFstream str(mesh_.time().path() / mesh_.name() + ".grf");
Info<< "Dumping Scotch graph file to " << str.name() << endl
<< "Use this in combination with gpart." << endl;
label version = 0;
str << version << nl;
// Numer of vertices
str << xadj.size()-1 << ' ' << adjncy.size() << nl;
// Numbering starts from 0
label baseval = 0;
// Has weights?
label hasEdgeWeights = 0;
label hasVertexWeights = 0;
label numericflag = 10*hasEdgeWeights+hasVertexWeights;
str << baseval << ' ' << numericflag << nl;
for (label cellI = 0; cellI < xadj.size()-1; cellI++)
{
label start = xadj[cellI];
label end = xadj[cellI+1];
str << end-start;
for (label i = start; i < end; i++)
{
str << ' ' << adjncy[i];
}
str << nl;
}
}
}
}
// Strategy
// ~~~~~~~~
// Default.
SCOTCH_Strat stradat;
check(SCOTCH_stratInit(&stradat), "SCOTCH_stratInit");
if (decompositionDict_.found("scotchCoeffs"))
{
const dictionary& scotchCoeffs =
decompositionDict_.subDict("scotchCoeffs");
string strategy;
if (scotchCoeffs.readIfPresent("strategy", strategy))
{
if (debug)
{
Info<< "scotchDecomp : Using strategy " << strategy << endl;
}
SCOTCH_stratGraphMap(&stradat, strategy.c_str());
//fprintf(stdout, "S\tStrat=");
//SCOTCH_stratSave(&stradat, stdout);
//fprintf(stdout, "\n");
}
}
// Graph
// ~~~~~
List<int> velotab;
// Check for externally provided cellweights and if so initialise weights
scalar minWeights = gMin(cWeights);
if (cWeights.size() > 0)
{
if (minWeights <= 0)
{
WarningIn
(
"scotchDecomp::decompose"
"(const pointField&, const scalarField&)"
) << "Illegal minimum weight " << minWeights
<< endl;
}
if (cWeights.size() != xadj.size()-1)
{
FatalErrorIn
(
"scotchDecomp::decompose"
"(const pointField&, const scalarField&)"
) << "Number of cell weights " << cWeights.size()
<< " does not equal number of cells " << xadj.size()-1
<< exit(FatalError);
}
// Convert to integers.
velotab.setSize(cWeights.size());
forAll(velotab, i)
{
velotab[i] = int(cWeights[i]/minWeights);
}
}
SCOTCH_Graph grafdat;
check(SCOTCH_graphInit(&grafdat), "SCOTCH_graphInit");
check
(
SCOTCH_graphBuild
(
&grafdat,
0, // baseval, c-style numbering
xadj.size()-1, // vertnbr, nCells
xadj.begin(), // verttab, start index per cell into adjncy
&xadj[1], // vendtab, end index ,,
velotab.begin(), // velotab, vertex weights
NULL, // vlbltab
adjncy.size(), // edgenbr, number of arcs
adjncy.begin(), // edgetab
NULL // edlotab, edge weights
),
"SCOTCH_graphBuild"
);
check(SCOTCH_graphCheck(&grafdat), "SCOTCH_graphCheck");
// Architecture
// ~~~~~~~~~~~~
// (fully connected network topology since using switch)
SCOTCH_Arch archdat;
check(SCOTCH_archInit(&archdat), "SCOTCH_archInit");
List<label> processorWeights;
if (decompositionDict_.found("scotchCoeffs"))
{
const dictionary& scotchCoeffs =
decompositionDict_.subDict("scotchCoeffs");
scotchCoeffs.readIfPresent("processorWeights", processorWeights);
}
if (processorWeights.size())
{
if (debug)
{
Info<< "scotchDecomp : Using procesor weights " << processorWeights
<< endl;
}
check
(
SCOTCH_archCmpltw(&archdat, nProcessors_, processorWeights.begin()),
"SCOTCH_archCmpltw"
);
}
else
{
check
(
SCOTCH_archCmplt(&archdat, nProcessors_),
"SCOTCH_archCmplt"
);
}
//SCOTCH_Mapping mapdat;
//SCOTCH_graphMapInit(&grafdat, &mapdat, &archdat, NULL);
//SCOTCH_graphMapCompute(&grafdat, &mapdat, &stradat); /* Perform mapping */
//SCOTCH_graphMapExit(&grafdat, &mapdat);
// Hack:switch off fpu error trapping
# ifdef LINUX_GNUC
int oldExcepts = fedisableexcept
(
FE_DIVBYZERO
| FE_INVALID
| FE_OVERFLOW
);
# endif
finalDecomp.setSize(xadj.size()-1);
finalDecomp = 0;
check
(
SCOTCH_graphMap
(
&grafdat,
&archdat,
&stradat, // const SCOTCH_Strat *
finalDecomp.begin() // parttab
),
"SCOTCH_graphMap"
);
# ifdef LINUX_GNUC
feenableexcept(oldExcepts);
# endif
//finalDecomp.setSize(xadj.size()-1);
//check
//(
// SCOTCH_graphPart
// (
// &grafdat,
// nProcessors_, // partnbr
// &stradat, // const SCOTCH_Strat *
// finalDecomp.begin() // parttab
// ),
// "SCOTCH_graphPart"
//);
// Release storage for graph
SCOTCH_graphExit(&grafdat);
// Release storage for strategy
SCOTCH_stratExit(&stradat);
// Release storage for network topology
SCOTCH_archExit(&archdat);
return 0;
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Strat bipastrat; /* Bipartitioning strategy */
SCOTCH_Arch archdat; /* Target (terminal) architecture */
SCOTCH_Graph grafdat; /* Source graph to turn into architecture */
SCOTCH_Num vertnbr; /* Number of vertices in graph */
SCOTCH_Num * vlbltab; /* Pointer to vertex label array, if present */
SCOTCH_Num listnbr; /* Size of list array */
SCOTCH_Num * listtab; /* Pointer to list array */
C_VertSort * sorttab; /* Vertex label sort area */
SCOTCH_Num baseval;
int flagval; /* Process flags */
int i;
errorProg ("amk_grf");
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
flagval = C_FLAGNONE;
SCOTCH_stratInit (&bipastrat);
fileBlockInit (C_fileTab, C_FILENBR); /* Set default stream pointers */
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_fileNum < C_FILEARGNBR) /* File name has been given */
fileBlockName (C_fileTab, C_fileNum ++) = argv[i];
else {
errorPrint ("main: too many file names given");
return (1);
}
}
else { /* If found an option name */
switch (argv[i][1]) {
case 'B' : /* Bipartitioning strategy */
case 'b' :
SCOTCH_stratExit (&bipastrat);
SCOTCH_stratInit (&bipastrat);
if ((SCOTCH_stratGraphBipart (&bipastrat, &argv[i][2])) != 0) {
errorPrint ("main: invalid bipartitioning strategy");
return (1);
}
break;
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'L' : /* Input vertex list */
case 'l' :
flagval |= C_FLAGVRTINP;
if (argv[i][2] != '\0')
C_filenamevrtinp = &argv[i][2];
break;
case 'V' :
fprintf (stderr, "amk_grf, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 2004,2007,2008,2010-2012,2014 IPB, Universite de Bordeaux, 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);
default :
errorPrint ("main: unprocessed option '%s'", argv[i]);
return (1);
}
}
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
SCOTCH_graphInit (&grafdat); /* Create graph structure */
SCOTCH_graphLoad (&grafdat, C_filepntrgrfinp, -1, 0); /* Load source graph */
SCOTCH_graphData (&grafdat, &baseval, &vertnbr, NULL, NULL, NULL, /* Get graph data */
&vlbltab, NULL, NULL, NULL);
listnbr = 0; /* Initialize vertex list */
listtab = NULL;
if (flagval & C_FLAGVRTINP) { /* If list of vertices provided */
SCOTCH_Num listnum;
if ((intLoad (C_filepntrvrtinp, &listnbr) != 1) || /* Read list size */
(listnbr < 0) ||
(listnbr > vertnbr)) {
errorPrint ("main: bad list input (1)");
return (1);
}
if ((listtab = (SCOTCH_Num *) memAlloc (listnbr * sizeof (SCOTCH_Num) + 1)) == NULL) {
errorPrint ("main: out of memory (1)");
return (1);
}
for (listnum = 0; listnum < listnbr; listnum ++) { /* Read list data */
if (intLoad (C_filepntrvrtinp, &listtab[listnum]) != 1) {
errorPrint ("main: bad list input (2)");
return (1);
}
}
intSort1asc1 (listtab, listnbr);
for (listnum = 0; listnum < listnbr - 1; listnum ++) { /* Search for duplicates */
if (listtab[listnum] == listtab[listnum + 1]) {
errorPrint ("main: duplicate list labels");
memFree (listtab);
return (1);
}
}
if (vlbltab != NULL) { /* If graph has vertex labels */
SCOTCH_Num vertnum;
if ((sorttab = (C_VertSort *) memAlloc (vertnbr * sizeof (C_VertSort))) == NULL) {
errorPrint ("main: out of memory (2)");
memFree (listtab);
return (1);
}
for (vertnum = 0; vertnum < vertnbr; vertnum ++) { /* Initialize sort area */
sorttab[vertnum].vlblnum = vlbltab[vertnum];
sorttab[vertnum].vertnum = vertnum;
}
intSort2asc1 (sorttab, vertnbr); /* Sort by ascending labels */
for (listnum = 0, vertnum = 0; listnum < listnbr; listnum ++) { /* For all labels in list */
while ((vertnum < vertnbr) && (sorttab[vertnum].vlblnum < listtab[listnum]))
vertnum ++; /* Search vertex graph with corresponding label */
if ((vertnum >= vertnbr) || /* If label not found */
(sorttab[vertnum].vlblnum > listtab[listnum])) {
errorPrint ("main: list label '" SCOTCH_NUMSTRING "' not in graph", (SCOTCH_Num) listtab[listnum]);
memFree (sorttab);
memFree (listtab);
return (1);
}
listtab[listnum] = sorttab[vertnum ++].vertnum; /* Replace label by number */
}
memFree (sorttab); /* Free sort area */
}
}
SCOTCH_archInit (&archdat); /* Initialize target architecture */
SCOTCH_archBuild (&archdat, &grafdat, listnbr, listtab, &bipastrat); /* Compute architecture */
SCOTCH_archSave (&archdat, C_filepntrtgtout); /* Write target architecture */
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end potential (un)compression tasks */
SCOTCH_graphExit (&grafdat); /* Free target graph */
SCOTCH_archExit (&archdat); /* Free target architecture */
SCOTCH_stratExit (&bipastrat); /* Free strategy string */
if (listtab != NULL) /* If vertex list provided */
memFree (listtab); /* Free it */
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
