/************************************************************************* * This function takes a bisection and constructs a minimum weight vertex * separator out of it. It uses the node-based separator refinement for it. **************************************************************************/ void ConstructSeparator(CtrlType *ctrl, GraphType *graph, float ubfactor) { int i, j, k, nvtxs, nbnd; idxtype *xadj, *where, *bndind; nvtxs = graph->nvtxs; xadj = graph->xadj; nbnd = graph->nbnd; bndind = graph->bndind; where = idxcopy(nvtxs, graph->where, idxwspacemalloc(ctrl, nvtxs)); /* Put the nodes in the boundary into the separator */ for (i=0; i<nbnd; i++) { j = bndind[i]; if (xadj[j+1]-xadj[j] > 0) /* Ignore islands */ where[j] = 2; } GKfree(&graph->rdata, LTERM); Allocate2WayNodePartitionMemory(ctrl, graph); idxcopy(nvtxs, where, graph->where); idxwspacefree(ctrl, nvtxs); ASSERT(IsSeparable(graph)); Compute2WayNodePartitionParams(ctrl, graph); ASSERT(CheckNodePartitionParams(graph)); FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); ASSERT(IsSeparable(graph)); }
/************************************************************************* * This function is the entry point of the separator refinement **************************************************************************/ void Refine2WayNode(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, float ubfactor) { IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr)); for (;;) { IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr)); if (ctrl->RType != 15) FM_2WayNodeBalance(ctrl, graph, ubfactor); switch (ctrl->RType) { case 1: FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); break; case 2: FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); break; case 3: FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); break; case 4: FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); break; case 5: FM_2WayNodeRefineEqWgt(ctrl, graph, 8); break; } IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr)); Project2WayNodePartition(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr)); } IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr)); }
/************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void GrowBisectionNode(CtrlType *ctrl, GraphType *graph, float ubfactor) { int i, j, k, nvtxs, drain, nleft, first, last, pwgts[2], tpwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *bndind; idxtype *queue, *touched, *gain, *bestwhere; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); queue = idxmalloc(nvtxs, "BisectGraph: queue"); touched = idxmalloc(nvtxs, "BisectGraph: touched"); tpwgts[0] = idxsum(nvtxs, vwgt); tpwgts[1] = tpwgts[0]/2; tpwgts[0] -= tpwgts[1]; maxpwgt[0] = ubfactor*tpwgts[0]; maxpwgt[1] = ubfactor*tpwgts[1]; minpwgt[0] = (1.0/ubfactor)*tpwgts[0]; minpwgt[1] = (1.0/ubfactor)*tpwgts[1]; /* Allocate memory for graph->rdata. Allocate sufficient memory for both edge and node */ graph->rdata = idxmalloc(5*nvtxs+3, "GrowBisectionNode: graph->rdata"); graph->pwgts = graph->rdata; graph->where = graph->rdata + 3; graph->bndptr = graph->rdata + nvtxs + 3; graph->bndind = graph->rdata + 2*nvtxs + 3; graph->nrinfo = (NRInfoType *)(graph->rdata + 3*nvtxs + 3); graph->id = graph->rdata + 3*nvtxs + 3; graph->ed = graph->rdata + 4*nvtxs + 3; where = graph->where; bndind = graph->bndind; nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS); bestcut = tpwgts[0]+tpwgts[1]; for (nbfs++; nbfs>0; nbfs--) { idxset(nvtxs, 0, touched); pwgts[1] = tpwgts[0]+tpwgts[1]; pwgts[0] = 0; idxset(nvtxs, 1, where); queue[0] = RandomInRange(nvtxs); touched[queue[0]] = 1; first = 0; last = 1; nleft = nvtxs-1; drain = 0; /* Start the BFS from queue to get a partition */ if (nbfs >= 1) { for (;;) { if (first == last) { /* Empty. Disconnected graph! */ if (nleft == 0 || drain) break; k = RandomInRange(nleft); for (i=0; i<nvtxs; i++) { if (touched[i] == 0) { if (k == 0) break; else k--; } } queue[0] = i; touched[i] = 1; first = 0; last = 1;; nleft--; } i = queue[first++]; if (pwgts[1]-vwgt[i] < minpwgt[1]) { drain = 1; continue; } where[i] = 0; INC_DEC(pwgts[0], pwgts[1], vwgt[i]); if (pwgts[1] <= maxpwgt[1]) break; drain = 0; for (j=xadj[i]; j<xadj[i+1]; j++) { k = adjncy[j]; if (touched[k] == 0) { queue[last++] = k; touched[k] = 1; nleft--; } } } } /************************************************************* * Do some partition refinement **************************************************************/ Compute2WayPartitionParams(ctrl, graph); Balance2Way(ctrl, graph, tpwgts, ubfactor); FM_2WayEdgeRefine(ctrl, graph, tpwgts, 4); /* Construct and refine the vertex separator */ for (i=0; i<graph->nbnd; i++) where[bndind[i]] = 2; Compute2WayNodePartitionParams(ctrl, graph); FM_2WayNodeRefine(ctrl, graph, ubfactor, 6); /* printf("ISep: [%d %d %d] %d\n", graph->pwgts[0], graph->pwgts[1], graph->pwgts[2], bestcut); */ if (bestcut > graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); Compute2WayNodePartitionParams(ctrl, graph); GKfree(&bestwhere, &queue, &touched, LTERM); }