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);
}
int
main (
int argc,
char * argv[])
{
INT * randtab;
int randnbr;
int randnum;
struct stat statdat;
FILE * fileptr;
int passnum;
if (argc != 3) {
errorPrint ("usage: %s file passnum", argv[0]);
return (1);
}
if ((randtab = malloc (RANDNBR * sizeof (INT))) == NULL) {
errorPrint ("main: out of memory");
return (1);
}
intRandInit (); /* Initialize random generator */
for (randnum = 0; randnum < RANDNBR; randnum ++)
randtab[randnum] = intRandVal (INTVALMAX);
intRandReset ();
passnum = (atoi (argv[2]) == 0); /* First pass to write file; second pass to read it */
if ((fileptr = fopen (argv[1], (passnum) ? "w+" : "r")) == NULL) {
errorPrint ("main: cannot open file");
return (1);
}
if (passnum) { /* If first pass */
for (randnum = 0; randnum < RANDNBR; randnum ++) {
if (randtab[randnum] != intRandVal (INTVALMAX)) {
errorPrint ("main: cannot replay random sequence");
return (1);
}
}
if (fwrite (randtab, sizeof (INT), RANDNBR, fileptr) < RANDNBR) {
errorPrint ("main: cannot write to file");
return (1);
}
sleep (1); /* Next run will not get the same time() value */
}
else { /* Second pass */
const char * const bufftab = "";
char * charptr;
int o;
if (fread (randtab, sizeof (INT), RANDNBR, fileptr) < RANDNBR) {
errorPrint ("main: cannot read from file");
return (1);
}
for (randnum = 0; randnum < RANDNBR; randnum ++) {
if (randtab[randnum] != intRandVal (INTVALMAX))
break;
}
o = (randnum == RANDNBR);
charptr = (o) ? "same" : "different";
#if ((defined COMMON_DEBUG) || (defined COMMON_RANDOM_FIXED_SEED) || (defined SCOTCH_DETERMINISTIC))
o ^= 1;
#endif /* ((defined COMMON_DEBUG) || (defined COMMON_RANDOM_FIXED_SEED) || (defined SCOTCH_DETERMINISTIC)) */
if (o) {
errorPrint ("main: two consecutive runs yield %s values.", charptr);
return (1);
}
printf ("Two consecutive runs yield %s values.\n", charptr);
}
fclose (fileptr);
free (randtab);
return (0);
}
int
SCOTCH_dgraphOrderComputeList (
SCOTCH_Dgraph * const grafptr, /*+ Graph to order +*/
SCOTCH_Dordering * const ordeptr, /*+ Ordering to compute +*/
const SCOTCH_Num listnbr, /*+ Number of vertices in list +*/
const SCOTCH_Num * const listtab, /*+ List of vertex indices to order +*/
SCOTCH_Strat * const stratptr) /*+ Ordering strategy +*/
{
Dorder * srcordeptr; /* Pointer to ordering */
DorderCblk * srccblkptr; /* Initial column block */
Dgraph * restrict srcgrafptr; /* Pointer to scotch graph */
Hdgraph srcgrafdat; /* Halo source graph structure */
Gnum srclistnbr; /* Number of items in list */
Gnum * restrict srclisttab; /* Subgraph vertex list */
const Strat * ordstratptr; /* Pointer to ordering strategy */
srcgrafptr = (Dgraph *) grafptr;
#ifdef SCOTCH_DEBUG_DGRAPH2
if (dgraphCheck (srcgrafptr) != 0) {
errorPrint ("SCOTCH_dgraphOrderComputeList: invalid input graph");
return (1);
}
#endif /* SCOTCH_DEBUG_DGRAPH2 */
if (*((Strat **) stratptr) == NULL) /* Set default ordering strategy if necessary */
SCOTCH_stratDgraphOrderBuild (stratptr, SCOTCH_STRATQUALITY, srcgrafptr->procglbnbr, 0, 0.2);
ordstratptr = *((Strat **) stratptr);
if (ordstratptr->tabl != &hdgraphorderststratab) {
errorPrint ("SCOTCH_dgraphOrderComputeList: not a distributed ordering strategy");
return (1);
}
srcgrafdat.s = *srcgrafptr; /* Copy non-halo graph data */
srcgrafdat.s.edloloctax = NULL; /* Never mind about edge loads */
srcgrafdat.s.vlblloctax = NULL; /* Do not propagate vertex labels */
srcgrafdat.vhallocnbr = 0; /* No halo on graph */
srcgrafdat.vhndloctax = srcgrafdat.s.vendloctax;
srcgrafdat.ehallocnbr = 0;
srcgrafdat.levlnum = 0;
srcordeptr = (Dorder *) ordeptr; /* Get ordering */
srclistnbr = (Gnum) listnbr; /* Build vertex list */
srclisttab = (Gnum *) listtab;
intRandInit (); /* Check that random number generator is initialized */
/* TODO: Take list into account */
dorderFree (srcordeptr); /* Clean all existing ordering data */
if ((srccblkptr = dorderFrst (srcordeptr)) == NULL) {
errorPrint ("SCOTCH_dgraphOrderComputeList: cannot create root column block");
return (1);
}
hdgraphOrderSt (&srcgrafdat, srccblkptr, ordstratptr);
dorderDispose (srccblkptr);
srcgrafptr->flagval |= srcgrafdat.s.flagval & (DGRAPHFREEEDGEGST | DGRAPHHASEDGEGST);
srcgrafptr->edgegsttax = srcgrafdat.s.edgegsttax; /* Get edge ghost array from working graph if it gained one */
*srcgrafptr = srcgrafdat.s; /* Get back Dgraph structure, possibly updated (additional ghost data arrays) */
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");
intRandInit ();
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
flagval = C_FLAGNONE;
SCOTCH_stratInit (&bipastrat);
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");
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,2011 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);
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);
}
int
main (
int argc,
char * argv[])
{
FiboHeap fibodat;
TestFibo * nodetab;
TestFibo * nodeptr;
int nodesiz;
int nodemax;
int nodenbr;
int nodenum;
int nodetmp;
int randval;
int randtmp;
int passnbr;
int passnum;
SCOTCH_errorProg (argv[0]);
if (fiboHeapInit (&fibodat, testFiboCmpFunc) != 0) {
SCOTCH_errorPrint ("main: cannot initialize Fibonacci heap");
exit (EXIT_FAILURE);
}
intRandInit (); /* Initialize random generator */
nodesiz = 100;
passnbr = -1;
switch (argc) {
case 4 :
intRandSeed (MAX (0, atoi (argv[3])));
case 3 :
passnbr = MAX (1, atoi (argv[2]));
case 2 :
nodesiz = MAX (1, atoi (argv[1]));
case 1 :
break;
default :
SCOTCH_errorPrint ("usage: %s [nodenbr [passnbr [seed]]]", argv[0]);
exit (EXIT_FAILURE);
}
if (passnbr < 0)
passnbr = 10 * nodesiz;
if ((nodetab = malloc (nodesiz * sizeof (TestFibo))) == NULL) {
SCOTCH_errorPrint ("main: out of memory");
exit (EXIT_FAILURE);
}
for (nodenum = 0; nodenum < nodesiz; nodenum ++) /* Initialize node array */
nodetab[nodenum].randval = -1;
nodemax = nodesiz - 1; /* Set maximum index */
nodenbr = 0; /* Array is empty */
for (passnum = 0; passnum < passnbr; passnum ++) {
switch (intRandVal (6)) {
case 0 : /* Add node */
case 1 :
case 2 : /* More additions than deletions on average */
if (nodenbr >= nodemax)
break;
for (nodenum = 0; nodenum <= nodemax; nodenum ++) { /* Search for a free slot */
if (nodetab[nodenum].randval < 0)
break;
}
if (nodenum > nodemax) {
SCOTCH_errorPrint ("main: invalid node array (1)");
exit (EXIT_FAILURE);
}
nodetab[nodenum].randval = abs (intRandVal (INTVALMAX));
fiboHeapAdd (&fibodat, (FiboNode *) &nodetab[nodenum]);
nodenbr ++;
break;
case 3 : /* Remove arbitrary node */
if (nodenbr <= 0)
break;
nodetmp = intRandVal (nodenbr);
for (nodenum = 0; ; nodenum ++) { /* Search for non-empty slot */
if (nodenum > nodemax) {
SCOTCH_errorPrint ("main: invalid node array (2)");
exit (EXIT_FAILURE);
}
if (nodetab[nodenum].randval >= 0) {
if (-- nodetmp <= 0)
break;
}
}
fiboHeapDel (&fibodat, (FiboNode *) &nodetab[nodenum]);
nodetab[nodenum].randval = -1;
nodenbr --;
break;
case 4 : /* Remove minimum node */
if (nodenbr <= 0)
break;
nodeptr = (TestFibo *) fiboHeapMin (&fibodat);
randval = nodeptr->randval; /* Keep node key value */
fiboHeapDel (&fibodat, (FiboNode *) nodeptr); /* Remove node first */
nodeptr->randval = -1;
nodenbr --;
for (nodenum = 0; nodenum <= nodemax; nodenum ++) { /* Check if smaller node exists */
if ((nodetab[nodenum].randval >= 0) &&
(nodetab[nodenum].randval < randval)) {
SCOTCH_errorPrint ("main: node is not of minimum key");
}
}
break;
case 5 : /* Decrease value of arbitrary node */
if (nodenbr <= 0)
break;
nodetmp = intRandVal (nodenbr);
for (nodenum = 0; ; nodenum ++) { /* Search for non-empty slot */
if (nodenum > nodemax) {
SCOTCH_errorPrint ("main: invalid node array (3)");
exit (EXIT_FAILURE);
}
if (nodetab[nodenum].randval >= 0) {
if (-- nodetmp <= 0)
break;
}
}
if (nodetab[nodenum].randval <= 0) /* Cannot decrease smallest value */
break;
randtmp = intRandVal (nodetab[nodenum].randval + 1);
if (randtmp > nodetab[nodenum].randval)
break;
nodetab[nodenum].randval -= randtmp;
fiboHeapDecrease (&fibodat, (FiboNode *) &nodetab[nodenum]);
break;
}
}
fiboHeapExit (&fibodat);
free (nodetab);
exit (EXIT_SUCCESS);
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Num vnodnbr; /* Number of nodes */
SCOTCH_Mesh meshdat; /* 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 ("mord");
intRandInit ();
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");
return (1);
}
}
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);
if ((SCOTCH_stratMeshOrder (&stradat, straptr)) != 0) {
errorPrint ("main: invalid ordering strategy");
return (1);
}
break;
case 'V' :
fprintf (stderr, "mord, 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);
break;
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]);
return (1);
}
}
break;
default :
errorPrint ("main: unprocessed option (\"%s\")", argv[i]);
return (1);
}
}
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
clockInit (&runtime[0]);
clockStart (&runtime[0]);
SCOTCH_meshInit (&meshdat); /* Create mesh structure */
SCOTCH_meshLoad (&meshdat, C_filepntrsrcinp, -1); /* Read source mesh */
SCOTCH_meshSize (&meshdat, NULL, &vnodnbr, NULL); /* Get number of nodes */
if (straval != 0) {
if (straptr != NULL)
errorPrint ("main: options '-c' and '-o' are exclusive");
SCOTCH_stratMeshOrderBuild (&stradat, straval, 0.1);
}
clockStop (&runtime[0]); /* Get input time */
clockInit (&runtime[1]);
clockStart (&runtime[1]);
if ((permtab = (SCOTCH_Num *) memAlloc (vnodnbr * sizeof (SCOTCH_Num))) == NULL) {
errorPrint ("main: out of memory");
return (1);
}
SCOTCH_meshOrderInit (&meshdat, &ordedat, permtab, NULL, NULL, NULL, NULL); /* Create ordering */
SCOTCH_meshOrderCompute (&meshdat, &ordedat, &stradat); /* Perform ordering */
clockStop (&runtime[1]); /* Get ordering time */
#ifdef SCOTCH_DEBUG_ALL
if (SCOTCH_meshOrderCheck (&meshdat, &ordedat) != 0)
return (1);
#endif /* SCOTCH_DEBUG_ALL */
clockStart (&runtime[0]);
SCOTCH_meshOrderSave (&meshdat, &ordedat, C_filepntrordout); /* Write ordering */
if (flagval & C_FLAGMAPOUT) /* If mapping wanted */
SCOTCH_meshOrderSaveMap (&meshdat, &ordedat, 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\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_meshOrderExit (&meshdat, &ordedat);
SCOTCH_stratExit (&stradat);
SCOTCH_meshExit (&meshdat);
memFree (permtab);
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
static
int
graphMapCompute2 (
SCOTCH_Graph * const grafptr, /*+ Graph to order +*/
SCOTCH_Mapping * const mappptr, /*+ Mapping to compute +*/
SCOTCH_Mapping * const mapoptr, /*+ Old mapping +*/
const double emraval, /*+ Edge migration ratio +*/
const SCOTCH_Num * vmlotab, /*+ Vertex migration cost array +*/
Gnum vfixval, /*+ Equal to 0 if no fixed vertices +*/
SCOTCH_Strat * const straptr) /*+ Mapping strategy +*/
{
Kgraph mapgrafdat; /* Effective mapping graph */
const Strat * mapstraptr; /* Pointer to mapping strategy */
LibMapping * restrict lmapptr;
LibMapping * restrict lmaoptr;
Anum * pfixtax;
Gnum baseval;
Anum * parttax; /* Partition array */
Anum * parotax; /* Old partition array */
Gnum crloval; /* Coefficient load for regular edges */
Gnum cmloval; /* Coefficient load for migration edges */
const Gnum * vmlotax; /* Vertex migration cost array */
Gnum vertnum;
Gnum vertnnd;
Gnum vertnbr;
int o;
lmapptr = (LibMapping *) mappptr;
#ifdef SCOTCH_DEBUG_GRAPH2
if ((Graph *) grafptr != lmapptr->grafptr) {
errorPrint ("graphMapCompute2: output mapping does not correspond to input graph");
return (1);
}
if (graphCheck ((Graph *) grafptr) != 0) { /* Vertex loads can be 0 if we have fixed vertices */
errorPrint ("graphMapCompute2: invalid input graph");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
if (*((Strat **) straptr) == NULL) { /* Set default mapping strategy if necessary */
ArchDom archdomnorg;
archDomFrst (lmapptr->archptr, &archdomnorg);
SCOTCH_stratGraphMapBuild (straptr, SCOTCH_STRATDEFAULT, archDomSize (lmapptr->archptr, &archdomnorg), 0.01);
}
mapstraptr = *((Strat **) straptr);
if (mapstraptr->tabl != &kgraphmapststratab) {
errorPrint ("graphMapCompute2: not a graph mapping strategy");
return (1);
}
baseval = lmapptr->grafptr->baseval;
vertnbr = lmapptr->grafptr->vertnbr;
if (mapoptr != NULL) { /* We are doing a repartitioning */
LibMapping * lmaoptr;
Gnum numeval;
Gnum denoval;
lmaoptr = (LibMapping *) mapoptr;
#ifdef SCOTCH_DEBUG_GRAPH2
if (lmapptr->grafptr != lmaoptr->grafptr) {
errorPrint ("graphMapCompute2: output and old mapping must correspond to the same graph");
return (1);
}
if (lmapptr->archptr != lmaoptr->archptr) {
errorPrint ("graphMapCompute2: output and old mapping must correspond to the same architecture");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
parotax = lmaoptr->parttab - baseval;
vmlotax = (vmlotab != NULL) ? vmlotab - baseval : NULL;
numeval = (INT) ((emraval * 100.0) + 0.5);
denoval = intGcd (numeval, 100);
cmloval = numeval / denoval;
crloval = 100 / denoval;
}
else {
parotax = NULL;
vmlotax = NULL;
cmloval =
crloval = 1;
}
parttax = NULL;
if (vfixval != 0) { /* We have fixed vertices */
#ifdef SCOTCH_DEBUG_GRAPH2
if (lmapptr->parttab == NULL) { /* We must have fixed vertices information */
errorPrint ("graphMapCompute2: missing output mapping part array");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
pfixtax = lmapptr->parttab - baseval;
if ((parttax = (Anum *) memAlloc (vertnbr * sizeof (Anum))) == NULL) {
errorPrint ("graphMapCompute2: out of memory (1)");
return (1);
}
memSet (parttax, 0, vertnbr * sizeof (Anum)); /* All vertices mapped to first domain */
parttax -= baseval;
} else {
pfixtax = NULL;
if (lmapptr->parttab == NULL) { /* If user mapping not initialized */
errorPrint ("graphMapCompute2: invalid user mapping");
return (1);
}
parttax = lmapptr->parttab - baseval;
}
intRandInit (); /* Check that random number generator is initialized */
if (kgraphInit (&mapgrafdat, (Graph *) grafptr, lmapptr->archptr, NULL, parttax, parotax, crloval, cmloval, vmlotax, pfixtax) != 0)
return (1);
o = 0;
if (mapgrafdat.vfixnbr != mapgrafdat.s.vertnbr) { /* Perform mapping if not all fixed vertices */
o = kgraphMapSt (&mapgrafdat, mapstraptr);
lmapptr->parttab -= baseval;
for (vertnum = baseval, vertnnd = vertnum + lmapptr->grafptr->vertnbr;
vertnum < vertnnd; vertnum ++)
lmapptr->parttab[vertnum] = archDomNum (lmapptr->archptr, &mapgrafdat.m.domntab[mapgrafdat.m.parttax[vertnum]]);
lmapptr->parttab += baseval;
}
if (vfixval != 0) /* We have fixed vertices */
memFree (parttax + baseval);
kgraphExit (&mapgrafdat);
return (o);
}
