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_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[]) { 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[]) { 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[]) { MPI_Comm proccomm; int procglbnbr; /* Number of processes sharing graph data */ int proclocnum; /* Number of this process */ SCOTCH_Num vertglbnbr; SCOTCH_Num vertlocnbr; SCOTCH_Num * fronloctab; SCOTCH_Num baseval; SCOTCH_Dgraph grafdat; SCOTCH_Dgraph bandgrafdat; SCOTCH_Num bandvertglbnbr; SCOTCH_Num bandvertlocnbr; SCOTCH_Num * bandvlblloctab; FILE * file; int procnum; #ifdef SCOTCH_PTHREAD int thrdlvlreqval; int thrdlvlproval; #endif /* SCOTCH_PTHREAD */ SCOTCH_errorProg (argv[0]); #ifdef SCOTCH_PTHREAD thrdlvlreqval = MPI_THREAD_MULTIPLE; if (MPI_Init_thread (&argc, &argv, thrdlvlreqval, &thrdlvlproval) != MPI_SUCCESS) SCOTCH_errorPrint ("main: Cannot initialize (1)"); if (thrdlvlreqval > thrdlvlproval) SCOTCH_errorPrint ("main: MPI implementation is not thread-safe: recompile without SCOTCH_PTHREAD"); #else /* SCOTCH_PTHREAD */ if (MPI_Init (&argc, &argv) != MPI_SUCCESS) SCOTCH_errorPrint ("main: Cannot initialize (2)"); #endif /* SCOTCH_PTHREAD */ if (argc != 2) { SCOTCH_errorPrint ("usage: %s graph_file", argv[0]); exit (EXIT_FAILURE); } proccomm = MPI_COMM_WORLD; MPI_Comm_size (proccomm, &procglbnbr); /* Get communicator data */ MPI_Comm_rank (proccomm, &proclocnum); fprintf (stderr, "Proc %2d of %2d, pid %d\n", proclocnum, procglbnbr, getpid ()); #ifdef SCOTCH_CHECK_NOAUTO if (proclocnum == 0) { /* Synchronize on keybord input */ char c; printf ("Waiting for key press...\n"); scanf ("%c", &c); } #endif /* SCOTCH_CHECK_NOAUTO */ if (MPI_Barrier (proccomm) != MPI_SUCCESS) { /* Synchronize for debug */ SCOTCH_errorPrint ("main: cannot communicate (1)"); exit (EXIT_FAILURE); } if (SCOTCH_dgraphInit (&grafdat, proccomm) != 0) { /* Initialize source graph */ SCOTCH_errorPrint ("main: cannot initialize graph (1)"); exit (EXIT_FAILURE); } file = NULL; if ((proclocnum == 0) && ((file = fopen (argv[1], "r")) == NULL)) { SCOTCH_errorPrint ("main: cannot open graph file"); exit (EXIT_FAILURE); } if (SCOTCH_dgraphLoad (&grafdat, file, 0, 0) != 0) { SCOTCH_errorPrint ("main: cannot load graph"); exit (EXIT_FAILURE); } if (file != NULL) fclose (file); if (MPI_Barrier (proccomm) != MPI_SUCCESS) { /* Synchronize for debug */ SCOTCH_errorPrint ("main: cannot communicate (2)"); exit (EXIT_FAILURE); } SCOTCH_dgraphData (&grafdat, NULL, &vertglbnbr, &vertlocnbr, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); if ((fronloctab = malloc (vertlocnbr * sizeof (SCOTCH_Num))) == NULL) { SCOTCH_errorPrint ("main: cannot allocate frontier array"); exit (EXIT_FAILURE); } if (SCOTCH_dgraphInit (&bandgrafdat, proccomm) != 0) { /* Initialize band graph */ SCOTCH_errorPrint ("main: cannot initialize graph (2)"); exit (EXIT_FAILURE); } fronloctab[0] = 0; if (SCOTCH_dgraphBand (&grafdat, (proclocnum == 1) ? 1 : 0, fronloctab, 4, &bandgrafdat) != 0) { SCOTCH_errorPrint ("main: cannot compute band graph"); exit (EXIT_FAILURE); } free (fronloctab); SCOTCH_dgraphData (&bandgrafdat, &baseval, &bandvertglbnbr, &bandvertlocnbr, NULL, NULL, NULL, NULL, NULL, &bandvlblloctab, NULL, NULL, NULL, NULL, NULL, NULL, NULL); for (procnum = 0; procnum < procglbnbr; procnum ++) { SCOTCH_Num bandvertlocnum; MPI_Barrier (proccomm); if (procnum == proclocnum) { if ((file = fopen ("/tmp/test_scotch_dgraph_band.map", (procnum == 0) ? "w" : "a+")) == NULL) { SCOTCH_errorPrint ("main: cannot open mapping file"); exit (EXIT_FAILURE); } if (procnum == 0) fprintf (file, "%ld\n", (long) bandvertglbnbr); for (bandvertlocnum = 0; bandvertlocnum < bandvertlocnbr; bandvertlocnum ++) fprintf (file, "%ld\t1\n", (long) bandvlblloctab[bandvertlocnum]); fclose (file); } } SCOTCH_dgraphExit (&bandgrafdat); SCOTCH_dgraphExit (&grafdat); MPI_Finalize (); exit (EXIT_SUCCESS); }
void METISNAMEU(ParMETIS_V3_NodeND) ( const int * const vtxdist, int * const xadj, int * const adjncy, const int * const numflag, const int * const options, /* Not used */ int * const order, int * const sizes, /* Of size twice the number of processors ; not used */ MPI_Comm * comm) { MPI_Comm proccomm; int procglbnbr; int proclocnum; SCOTCH_Num baseval; SCOTCH_Dgraph grafdat; /* Scotch distributed graph object to interface with libScotch */ SCOTCH_Dordering ordedat; /* Scotch distributed ordering object to interface with libScotch */ SCOTCH_Strat stradat; SCOTCH_Num vertlocnbr; SCOTCH_Num edgelocnbr; if (sizeof (SCOTCH_Num) != sizeof (int)) { SCOTCH_errorPrint ("ParMETIS_V3_NodeND (as of SCOTCH): SCOTCH_Num type should equate to int"); return; } proccomm = *comm; if (SCOTCH_dgraphInit (&grafdat, proccomm) != 0) return; MPI_Comm_size (proccomm, &procglbnbr); MPI_Comm_rank (proccomm, &proclocnum); baseval = *numflag; vertlocnbr = vtxdist[proclocnum + 1] - vtxdist[proclocnum]; edgelocnbr = xadj[vertlocnbr] - baseval; if (sizes != NULL) memSet (sizes, ~0, (2 * procglbnbr - 1) * sizeof (int)); /* Array not used if procglbnbr is not a power of 2 or if error */ if (SCOTCH_dgraphBuild (&grafdat, baseval, vertlocnbr, vertlocnbr, xadj, xadj + 1, NULL, NULL, edgelocnbr, edgelocnbr, adjncy, NULL, NULL) == 0) { SCOTCH_stratInit (&stradat); #ifdef SCOTCH_DEBUG_ALL if (SCOTCH_dgraphCheck (&grafdat) == 0) /* TRICK: next instruction called only if graph is consistent */ #endif /* SCOTCH_DEBUG_ALL */ { if (SCOTCH_dgraphOrderInit (&grafdat, &ordedat) == 0) { int levlmax; int bitsnbr; SCOTCH_Num proctmp; SCOTCH_dgraphOrderCompute (&grafdat, &ordedat, &stradat); SCOTCH_dgraphOrderPerm (&grafdat, &ordedat, order); for (levlmax = -1, bitsnbr = 0, proctmp = procglbnbr; /* Count number of bits set to 1 in procglbnbr */ proctmp != 0; levlmax ++, proctmp >>= 1) bitsnbr += proctmp & 1; if (bitsnbr == 1) { SCOTCH_Num cblkglbnbr; if ((cblkglbnbr = SCOTCH_dgraphOrderCblkDist (&grafdat, &ordedat)) >= 0) { SCOTCH_Num * treeglbtab; SCOTCH_Num * sizeglbtab; SCOTCH_Num * sepaglbtab; if (memAllocGroup ((void **) (void *) &treeglbtab, (size_t) (cblkglbnbr * sizeof (SCOTCH_Num)), &sizeglbtab, (size_t) (cblkglbnbr * sizeof (SCOTCH_Num)), &sepaglbtab, (size_t) (cblkglbnbr * sizeof (SCOTCH_Num) * 3), NULL) != NULL) { if (SCOTCH_dgraphOrderTreeDist (&grafdat, &ordedat, treeglbtab, sizeglbtab) == 0) { SCOTCH_Num rootnum; SCOTCH_Num cblknum; memSet (sepaglbtab, ~0, cblkglbnbr * sizeof (SCOTCH_Num) * 3); for (rootnum = -1, cblknum = 0; cblknum < cblkglbnbr; cblknum ++) { SCOTCH_Num fathnum; fathnum = treeglbtab[cblknum] - baseval; /* Use un-based indices */ if (fathnum < 0) { /* If father index indicates root */ if (rootnum != -1) { /* If another root already found */ rootnum = -1; /* Indicate an error */ break; } rootnum = cblknum; /* Record index of root node */ } else { int i; for (i = 0; i < 3; i ++) { int j; j = 3 * fathnum + i; /* Slot number of prospective son */ if (sepaglbtab[j] < 0) { /* If potentially empty slot found */ if (sepaglbtab[j] == -1) /* If we don't have too many sons */ sepaglbtab[j] = cblknum; /* Add link to son in slot */ break; } } if (i == 3) { /* If no empty slot found */ sepaglbtab[3 * fathnum] = -2; /* Indicate there are too many sons */ break; } } } if ((rootnum >= 0) && (sizes != NULL)) { /* If no error above, go on processing separator tree */ memSet (sizes, 0, (2 * procglbnbr - 1) * sizeof (int)); /* Set array of sizes to 0 by default */ _SCOTCH_ParMETIS_V3_NodeNDTree (sizes + (2 * procglbnbr - 1), sizeglbtab, sepaglbtab, levlmax, 0, rootnum, 1); } } memFree (treeglbtab); /* Free group leader */ } } } SCOTCH_dgraphOrderExit (&grafdat, &ordedat); } }