int
main (
int argc,
char * argv[])
{
FILE * fileptr;
SCOTCH_Graph grafdat;
SCOTCH_Num vertnbr;
SCOTCH_Graph_64 grafdat_64;
SCOTCH_Num_64 vertnbr_64;
SCOTCH_errorProg (argv[0]);
if (argc != 2) {
SCOTCH_errorPrint ("usage: %s graph_file", argv[0]);
exit (EXIT_FAILURE);
}
if ((SCOTCH_graphInit (&grafdat) != 0) ||
(SCOTCH_graphInit_64 (&grafdat_64) != 0)) { /* Initialize source graph */
SCOTCH_errorPrint ("main: cannot initialize graph");
exit (EXIT_FAILURE);
}
if ((fileptr = fopen (argv[1], "r")) == NULL) {
SCOTCH_errorPrint ("main: cannot open file (1)");
exit (EXIT_FAILURE);
}
if (SCOTCH_graphLoad (&grafdat, fileptr, -1, 0) != 0) { /* Read source graph */
SCOTCH_errorPrint ("main: cannot load graph (1)");
exit (EXIT_FAILURE);
}
fclose (fileptr);
if ((fileptr = fopen (argv[1], "r")) == NULL) {
SCOTCH_errorPrint ("main: cannot open file (2)");
exit (EXIT_FAILURE);
}
if (SCOTCH_graphLoad_64 (&grafdat_64, fileptr, -1, 0) != 0) { /* Read source graph */
SCOTCH_errorPrint ("main: cannot load graph (2)");
exit (EXIT_FAILURE);
}
fclose (fileptr);
SCOTCH_graphSize (&grafdat, &vertnbr, NULL);
SCOTCH_graphSize_64 (&grafdat_64, &vertnbr_64, NULL);
SCOTCH_graphExit (&grafdat);
SCOTCH_graphExit_64 (&grafdat_64);
exit (EXIT_SUCCESS);
}
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);
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Graph grafdat; /* Source graph */
int baseval;
int i;
errorProg ("gbase");
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
exit (0);
}
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 < 1) { /* If number of parameters not reached */
C_paraNum ++; /* One more parameter */
baseval = atoi (argv[i]); /* Get the base value */
if ((baseval < 0) || (baseval > 1)) {
errorPrint ("main: invalid base value '%s'", argv[i]);
return (1);
}
continue; /* Process the other parameters */
}
if (C_fileNum < C_FILEARGNBR) /* A file name has been given */
C_fileTab[C_fileNum ++].name = argv[i];
else {
errorPrint ("main: too many file names given");
exit (1);
}
}
else { /* If found an option name */
switch (argv[i][1]) {
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
exit (0);
case 'V' :
fprintf (stderr, "gbase, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 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);
default :
errorPrint ("main: unprocessed option '%s'", argv[i]);
exit (1);
}
}
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
SCOTCH_graphInit (&grafdat);
SCOTCH_graphLoad (&grafdat, C_filepntrsrcinp, (SCOTCH_Num) baseval, 0);
SCOTCH_graphSave (&grafdat, C_filepntrsrcout);
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
SCOTCH_graphExit (&grafdat);
#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[])
{
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[])
{
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);
}
int
main (
int argc,
char * argv[])
{
C_Graph grafdat; /* Source graph */
C_Geometry geo; /* Graph geometry */
C_Mapping map; /* Result mapping */
int i, j;
errorProg ("gout");
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
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 'G' : /* Geometry parameters */
case 'g' :
if ((j = C_geoParse (&argv[i][2])) != 0)
errorPrint ("main: error in geometry option string '%d'", j);
break;
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'M' : /* No-mapping flag */
case 'm' :
if (((argv[i][2] != 'N') && (argv[i][2] != 'n')) || (argv[i][3] != '\0'))
errorPrint ("main: error in mapping option string '%s'", &argv[i][2]);
C_filenamemapinp = "-"; /* Default name to avoid opening */
C_filepntrmapinp = NULL; /* NULL file pointer means no file */
break;
case 'O' : /* Output parameters */
case 'o' :
if ((j = outDrawParse (&argv[i][2])) != 0)
errorPrint ("main: error in output option string (%d)", j);
break;
case 'V' :
fprintf (stderr, "gout, 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);
default :
errorPrint ("main: Unprocessed option '%s'", argv[i]);
}
}
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
SCOTCH_graphInit (&grafdat.grafdat); /* Create graph structure */
SCOTCH_graphLoad (&grafdat.grafdat, C_filepntrsrcinp, 0, 3); /* Read source graph */
SCOTCH_graphData (&grafdat.grafdat, &grafdat.baseval,
&grafdat.vertnbr, &grafdat.verttab, &grafdat.vendtab, NULL, &grafdat.vlbltab,
&grafdat.edgenbr, &grafdat.edgetab, NULL);
C_geoInit (&geo, &grafdat); /* Create geometry structure */
if (C_geoFlag & C_GEOFLAGUSE) /* If geometry is wanted */
C_geoLoad (&geo, C_filepntrgeoinp); /* Read graph geometry */
C_mapInit (&map, &grafdat); /* Create mapping structure */
C_mapLoad (&map, C_filepntrmapinp); /* Read result mapping */
outDraw (&grafdat, &geo, &map, C_filepntrdatout); /* Build and write the output */
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
C_mapExit (&map); /* Free data structures */
C_geoExit (&geo);
SCOTCH_graphExit (&grafdat.grafdat);
#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[])
{
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);
}
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);
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Graph grafdat;
SCOTCH_Num vertnbr;
SCOTCH_Num * verttab;
SCOTCH_Num * vendtab;
SCOTCH_Num edgenbr;
SCOTCH_Num * edgetab;
SCOTCH_Num baseval;
SCOTCH_Ordering ordedat;
SCOTCH_Num * permtab;
SCOTCH_Num * peritab;
int i;
errorProg ("gotst");
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
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 'H' : /* Give help */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'V' :
fprintf (stderr, "gotst, 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);
SCOTCH_graphLoad (&grafdat, C_filepntrgrfinp, -1, 3);
SCOTCH_graphData (&grafdat, &baseval, &vertnbr, &verttab, &vendtab, NULL, NULL, &edgenbr, &edgetab, NULL);
#ifdef SCOTCH_DEBUG_ALL
if (vendtab != (verttab + 1)) {
errorPrint ("main: graph should be compact");
return (1);
}
#endif /* SCOTCH_DEBUG_ALL */
if (memAllocGroup ((void **) (void *)
&peritab, (size_t) (vertnbr * sizeof (SCOTCH_Num)),
&permtab, (size_t) (vertnbr * sizeof (SCOTCH_Num)), NULL) == NULL) {
errorPrint ("main: out of memory");
return (1);
}
SCOTCH_graphOrderInit (&grafdat, &ordedat, permtab, peritab, NULL, NULL, NULL);
SCOTCH_graphOrderLoad (&grafdat, &ordedat, C_filepntrordinp);
if (SCOTCH_graphOrderCheck (&grafdat, &ordedat) != 0) {
errorPrint ("main: invalid ordering");
return (1);
}
factorView (baseval, vertnbr, verttab, edgenbr, edgetab, permtab, peritab, C_filepntrdatout);
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
memFree (peritab);
SCOTCH_graphOrderExit (&grafdat, &ordedat);
SCOTCH_graphExit (&grafdat);
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
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);
}