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); }