void MlevelNestedDissectionCC(ctrl_t *ctrl, graph_t *graph, idx_t *order,
idx_t lastvtx)
{
idx_t i, j, nvtxs, nbnd, ncmps, rnvtxs, snvtxs;
idx_t *label, *bndind;
idx_t *cptr, *cind;
graph_t **sgraphs;
nvtxs = graph->nvtxs;
MlevelNodeBisectionMultiple(ctrl, graph);
IFSET(ctrl->dbglvl, METIS_DBG_SEPINFO,
printf("Nvtxs: %6"PRIDX", [%6"PRIDX" %6"PRIDX" %6"PRIDX"]\n",
graph->nvtxs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2]));
/* Order the nodes in the separator */
nbnd = graph->nbnd;
bndind = graph->bndind;
label = graph->label;
for (i=0; i<nbnd; i++)
order[label[bndind[i]]] = --lastvtx;
WCOREPUSH;
cptr = iwspacemalloc(ctrl, nvtxs+1);
cind = iwspacemalloc(ctrl, nvtxs);
ncmps = FindSepInducedComponents(ctrl, graph, cptr, cind);
if (ctrl->dbglvl&METIS_DBG_INFO) {
if (ncmps > 2)
printf(" Bisection resulted in %"PRIDX" connected components\n", ncmps);
}
sgraphs = SplitGraphOrderCC(ctrl, graph, ncmps, cptr, cind);
WCOREPOP;
/* Free the memory of the top level graph */
FreeGraph(&graph);
/* Go and process the subgraphs */
for (rnvtxs=i=0; i<ncmps; i++) {
/* Save the number of vertices in sgraphs[i] because sgraphs[i] is freed
inside MlevelNestedDissectionCC, and as such it will be undefined. */
snvtxs = sgraphs[i]->nvtxs;
if (sgraphs[i]->nvtxs > MMDSWITCH && sgraphs[i]->nedges > 0) {
MlevelNestedDissectionCC(ctrl, sgraphs[i], order, lastvtx-rnvtxs);
}
else {
MMDOrder(ctrl, sgraphs[i], order, lastvtx-rnvtxs);
FreeGraph(&sgraphs[i]);
}
rnvtxs += snvtxs;
}
gk_free((void **)&sgraphs, LTERM);
}
void McRandomBisection(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts,
idx_t niparts)
{
idx_t i, ii, j, k, nvtxs, ncon, from, bestcut=0, mincut, inbfs, qnum;
idx_t *bestwhere, *where, *perm, *counts;
idx_t *vwgt;
WCOREPUSH;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
vwgt = graph->vwgt;
Allocate2WayPartitionMemory(ctrl, graph);
where = graph->where;
bestwhere = iwspacemalloc(ctrl, nvtxs);
perm = iwspacemalloc(ctrl, nvtxs);
counts = iwspacemalloc(ctrl, ncon);
for (inbfs=0; inbfs<2*niparts; inbfs++) {
irandArrayPermute(nvtxs, perm, nvtxs/2, 1);
iset(ncon, 0, counts);
/* partition by spliting the queues randomly */
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
qnum = iargmax(ncon, vwgt+i*ncon);
where[i] = (counts[qnum]++)%2;
}
Compute2WayPartitionParams(ctrl, graph);
FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
Balance2Way(ctrl, graph, ntpwgts);
FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
Balance2Way(ctrl, graph, ntpwgts);
FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
if (inbfs == 0 || bestcut >= graph->mincut) {
bestcut = graph->mincut;
icopy(nvtxs, where, bestwhere);
if (bestcut == 0)
break;
}
}
graph->mincut = bestcut;
icopy(nvtxs, bestwhere, where);
WCOREPOP;
}
void GrowBisectionNode2(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts,
idx_t niparts)
{
idx_t i, j, k, nvtxs, bestcut=0, mincut, inbfs;
idx_t *xadj, *where, *bndind, *bestwhere;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
/* Allocate refinement memory. Allocate sufficient memory for both edge and node */
graph->pwgts = imalloc(3, "GrowBisectionNode: pwgts");
graph->where = imalloc(nvtxs, "GrowBisectionNode: where");
graph->bndptr = imalloc(nvtxs, "GrowBisectionNode: bndptr");
graph->bndind = imalloc(nvtxs, "GrowBisectionNode: bndind");
graph->id = imalloc(nvtxs, "GrowBisectionNode: id");
graph->ed = imalloc(nvtxs, "GrowBisectionNode: ed");
graph->nrinfo = (nrinfo_t *)gk_malloc(nvtxs*sizeof(nrinfo_t), "GrowBisectionNode: nrinfo");
bestwhere = iwspacemalloc(ctrl, nvtxs);
where = graph->where;
bndind = graph->bndind;
for (inbfs=0; inbfs<niparts; inbfs++) {
iset(nvtxs, 1, where);
if (inbfs > 0)
where[irandInRange(nvtxs)] = 0;
Compute2WayPartitionParams(ctrl, graph);
General2WayBalance(ctrl, graph, ntpwgts);
FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
/* Construct and refine the vertex separator */
for (i=0; i<graph->nbnd; i++) {
j = bndind[i];
if (xadj[j+1]-xadj[j] > 0) /* ignore islands */
where[j] = 2;
}
Compute2WayNodePartitionParams(ctrl, graph);
FM_2WayNodeRefine2Sided(ctrl, graph, 4);
/*
printf("ISep: [%"PRIDX" %"PRIDX" %"PRIDX" %"PRIDX"] %"PRIDX"\n",
inbfs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2], bestcut);
*/
if (inbfs == 0 || bestcut > graph->mincut) {
bestcut = graph->mincut;
icopy(nvtxs, where, bestwhere);
}
}
graph->mincut = bestcut;
icopy(nvtxs, bestwhere, where);
WCOREPOP;
}
/*************************************************************************
* This function keeps one parts
**************************************************************************/
void KeepPart(ctrl_t *ctrl, graph_t *graph, idx_t *part, idx_t mypart)
{
idx_t h, i, j, k;
idx_t nvtxs, ncon, mynvtxs, mynedges;
idx_t *xadj, *vwgt, *adjncy, *adjwgt, *label;
idx_t *rename;
WCOREPUSH;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
label = graph->label;
rename = iwspacemalloc(ctrl, nvtxs);
for (mynvtxs=0, i=0; i<nvtxs; i++) {
if (part[i] == mypart)
rename[i] = mynvtxs++;
}
for (mynvtxs=0, mynedges=0, j=xadj[0], i=0; i<nvtxs; i++) {
if (part[i] == mypart) {
for (; j<xadj[i+1]; j++) {
k = adjncy[j];
if (part[k] == mypart) {
adjncy[mynedges] = rename[k];
adjwgt[mynedges++] = adjwgt[j];
}
}
j = xadj[i+1]; /* Save xadj[i+1] for later use */
for (h=0; h<ncon; h++)
vwgt[mynvtxs*ncon+h] = vwgt[i*ncon+h];
label[mynvtxs] = label[i];
xadj[++mynvtxs] = mynedges;
}
else {
j = xadj[i+1]; /* Save xadj[i+1] for later use */
}
}
graph->nvtxs = mynvtxs;
graph->nedges = mynedges;
WCOREPOP;
}
void ComputeBFSOrdering(ctrl_t *ctrl, graph_t *graph, idx_t *bfsperm)
{
idx_t i, j, k, nvtxs, first, last;
idx_t *xadj, *adjncy, *perm;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
/* Allocate memory required for the BFS traversal */
perm = iincset(nvtxs, 0, iwspacemalloc(ctrl, nvtxs));
iincset(nvtxs, 0, bfsperm); /* this array will also store the vertices
still to be processed */
/* Find the connected componends induced by the partition */
first = last = 0;
while (first < nvtxs) {
if (first == last) { /* Find another starting vertex */
k = bfsperm[last];
ASSERT(perm[k] != -1);
perm[k] = -1; /* mark node as being visited */
last++;
}
i = bfsperm[first++];
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = adjncy[j];
/* if a node has been already been visited, its perm[] will be -1 */
if (perm[k] != -1) {
/* perm[k] is the location within bfsperm of where k resides;
put in that location bfsperm[last] that we are about to
overwrite and update perm[bfsperm[last]] to reflect that. */
bfsperm[perm[k]] = bfsperm[last];
perm[bfsperm[last]] = perm[k];
bfsperm[last++] = k; /* put node at the end of the "queue" */
perm[k] = -1; /* mark node as being visited */
}
}
}
WCOREPOP;
}
void MlevelNodeBisectionL2(ctrl_t *ctrl, graph_t *graph, idx_t niparts)
{
idx_t i, mincut, nruns=5;
graph_t *cgraph;
idx_t *bestwhere;
/* if the graph is small, just find a single vertex separator */
if (graph->nvtxs < 5000) {
MlevelNodeBisectionL1(ctrl, graph, niparts);
return;
}
WCOREPUSH;
ctrl->CoarsenTo = gk_max(100, graph->nvtxs/30);
cgraph = CoarsenGraphNlevels(ctrl, graph, 4);
bestwhere = iwspacemalloc(ctrl, cgraph->nvtxs);
mincut = graph->tvwgt[0];
for (i=0; i<nruns; i++) {
MlevelNodeBisectionL1(ctrl, cgraph, 0.7*niparts);
if (i == 0 || cgraph->mincut < mincut) {
mincut = cgraph->mincut;
if (i < nruns-1)
icopy(cgraph->nvtxs, cgraph->where, bestwhere);
}
if (mincut == 0)
break;
if (i < nruns-1)
FreeRData(cgraph);
}
if (mincut != cgraph->mincut)
icopy(cgraph->nvtxs, bestwhere, cgraph->where);
WCOREPOP;
Refine2WayNode(ctrl, graph, cgraph);
}
void InitKWayPartitioningGrow(ctrl_t *ctrl, graph_t *graph)
{
idx_t ntrials, curobj=0, bestobj=0;
idx_t *bestwhere=NULL;
WCOREPUSH;
bestwhere = iwspacemalloc(ctrl, graph->nvtxs);
for (ntrials=0; ntrials<ctrl->nIparts; ntrials++) {
GrowKWayPartitioning(ctrl, graph);
switch (ctrl->objtype) {
case METIS_OBJTYPE_CUT:
curobj = graph->mincut;
break;
case METIS_OBJTYPE_VOL:
curobj = graph->minvol;
break;
default:
gk_errexit(SIGERR, "Unknown objtype: %d\n", ctrl->objtype);
}
printf(" Ipart.%"PRIDX" curobj: %"PRIDX"\n", ntrials, curobj);
if (ntrials == 0 || bestobj > curobj) {
icopy(graph->nvtxs, graph->where, bestwhere);
bestobj = curobj;
}
}
if (bestobj != curobj)
icopy(graph->nvtxs, bestwhere, graph->where);
printf(" Ipart Select bestobj: %"PRIDX"\n", bestobj);
WCOREPOP;
}
void MlevelNodeBisectionMultiple(ctrl_t *ctrl, graph_t *graph)
{
idx_t i, mincut;
idx_t *bestwhere;
/* if the graph is small, just find a single vertex separator */
if (ctrl->nseps == 1 || graph->nvtxs < (ctrl->compress ? 1000 : 2000)) {
MlevelNodeBisectionL2(ctrl, graph, LARGENIPARTS);
return;
}
WCOREPUSH;
bestwhere = iwspacemalloc(ctrl, graph->nvtxs);
mincut = graph->tvwgt[0];
for (i=0; i<ctrl->nseps; i++) {
MlevelNodeBisectionL2(ctrl, graph, LARGENIPARTS);
if (i == 0 || graph->mincut < mincut) {
mincut = graph->mincut;
if (i < ctrl->nseps-1)
icopy(graph->nvtxs, graph->where, bestwhere);
}
if (mincut == 0)
break;
if (i < ctrl->nseps-1)
FreeRData(graph);
}
if (mincut != graph->mincut) {
icopy(graph->nvtxs, bestwhere, graph->where);
Compute2WayNodePartitionParams(ctrl, graph);
}
WCOREPOP;
}
void McGrowBisection(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts,
idx_t niparts)
{
idx_t i, j, k, nvtxs, ncon, from, bestcut=0, mincut, inbfs;
idx_t *bestwhere, *where;
WCOREPUSH;
nvtxs = graph->nvtxs;
Allocate2WayPartitionMemory(ctrl, graph);
where = graph->where;
bestwhere = iwspacemalloc(ctrl, nvtxs);
for (inbfs=0; inbfs<2*niparts; inbfs++) {
iset(nvtxs, 1, where);
where[irandInRange(nvtxs)] = 0;
Compute2WayPartitionParams(ctrl, graph);
Balance2Way(ctrl, graph, ntpwgts);
FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
Balance2Way(ctrl, graph, ntpwgts);
FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
if (inbfs == 0 || bestcut >= graph->mincut) {
bestcut = graph->mincut;
icopy(nvtxs, where, bestwhere);
if (bestcut == 0)
break;
}
}
graph->mincut = bestcut;
icopy(nvtxs, bestwhere, where);
WCOREPOP;
}
void MMDOrder(ctrl_t *ctrl, graph_t *graph, idx_t *order, idx_t lastvtx)
{
idx_t i, j, k, nvtxs, nofsub, firstvtx;
idx_t *xadj, *adjncy, *label;
idx_t *perm, *iperm, *head, *qsize, *list, *marker;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
/* Relabel the vertices so that it starts from 1 */
k = xadj[nvtxs];
for (i=0; i<k; i++)
adjncy[i]++;
for (i=0; i<nvtxs+1; i++)
xadj[i]++;
perm = iwspacemalloc(ctrl, nvtxs+5);
iperm = iwspacemalloc(ctrl, nvtxs+5);
head = iwspacemalloc(ctrl, nvtxs+5);
qsize = iwspacemalloc(ctrl, nvtxs+5);
list = iwspacemalloc(ctrl, nvtxs+5);
marker = iwspacemalloc(ctrl, nvtxs+5);
genmmd(nvtxs, xadj, adjncy, iperm, perm, 1, head, qsize, list, marker, IDX_MAX, &nofsub);
label = graph->label;
firstvtx = lastvtx-nvtxs;
for (i=0; i<nvtxs; i++)
order[label[i]] = firstvtx+iperm[i]-1;
/* Relabel the vertices so that it starts from 0 */
for (i=0; i<nvtxs+1; i++)
xadj[i]--;
k = xadj[nvtxs];
for (i=0; i<k; i++)
adjncy[i]--;
WCOREPOP;
}
void Match_Global(ctrl_t *ctrl, graph_t *graph)
{
idx_t h, i, ii, j, k;
idx_t nnbrs, nvtxs, ncon, cnvtxs, firstvtx, lastvtx, maxi, maxidx, nkept;
idx_t otherlastvtx, nrequests, nchanged, pass, nmatched, wside;
idx_t *xadj, *adjncy, *adjwgt, *vtxdist, *home, *myhome;
idx_t *match;
idx_t *peind, *sendptr, *recvptr;
idx_t *perm, *iperm, *nperm, *changed;
real_t *nvwgt, maxnvwgt;
idx_t *nreqs_pe;
ikv_t *match_requests, *match_granted, *pe_requests;
idx_t last_unmatched;
WCOREPUSH;
maxnvwgt = 0.75/((real_t)(ctrl->CoarsenTo));
graph->match_type = PARMETIS_MTYPE_GLOBAL;
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->comm));
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
home = graph->home;
nvwgt = graph->nvwgt;
vtxdist = graph->vtxdist;
firstvtx = vtxdist[ctrl->mype];
lastvtx = vtxdist[ctrl->mype+1];
nnbrs = graph->nnbrs;
peind = graph->peind;
sendptr = graph->sendptr;
recvptr = graph->recvptr;
match = graph->match = ismalloc(nvtxs+graph->nrecv, UNMATCHED, "GlobalMatch: match");
/* wspacemalloc'ed arrays */
myhome = iset(nvtxs+graph->nrecv, UNMATCHED, iwspacemalloc(ctrl, nvtxs+graph->nrecv));
nreqs_pe = iset(nnbrs, 0, iwspacemalloc(ctrl, nnbrs));
perm = iwspacemalloc(ctrl, nvtxs);
iperm = iwspacemalloc(ctrl, nvtxs);
nperm = iwspacemalloc(ctrl, nnbrs);
changed = iwspacemalloc(ctrl, nvtxs);
match_requests = ikvwspacemalloc(ctrl, graph->nsend);
match_granted = ikvwspacemalloc(ctrl, graph->nrecv);
/* create the traversal order */
FastRandomPermute(nvtxs, perm, 1);
for (i=0; i<nvtxs; i++)
iperm[perm[i]] = i;
iincset(nnbrs, 0, nperm);
/* if coasening for adaptive/repartition, exchange home information */
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION) {
PASSERT(ctrl, home != NULL);
icopy(nvtxs, home, myhome);
CommInterfaceData(ctrl, graph, myhome, myhome+nvtxs);
}
/* if coarsening for ordering, replace home with where information */
if (ctrl->partType == ORDER_PARTITION) {
PASSERT(ctrl, graph->where != NULL);
icopy(nvtxs, graph->where, myhome);
CommInterfaceData(ctrl, graph, myhome, myhome+nvtxs);
}
/* mark all heavy vertices as TOO_HEAVY so they will not be matched */
for (nchanged=i=0; i<nvtxs; i++) {
for (h=0; h<ncon; h++) {
if (nvwgt[i*ncon+h] > maxnvwgt) {
match[i] = TOO_HEAVY;
nchanged++;
break;
}
}
}
/* If no heavy vertices, pick one at random and treat it as such so that
at the end of the matching each partition will still have one vertex.
This is to eliminate the cases in which once a matching has been
computed, a processor ends up having no vertices */
if (nchanged == 0)
match[RandomInRange(nvtxs)] = TOO_HEAVY;
CommInterfaceData(ctrl, graph, match, match+nvtxs);
/* set initial value of nkept based on how over/under weight the
partition is to begin with */
nkept = graph->gnvtxs/ctrl->npes - nvtxs;
/* Find a matching by doing multiple iterations */
for (nmatched=pass=0; pass<NMATCH_PASSES; pass++) {
wside = (graph->level+pass)%2;
nchanged = nrequests = 0;
for (last_unmatched=ii=nmatched; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
maxidx = i;
maxi = -1;
/* Deal with islands. Find another vertex and match it with */
if (xadj[i] == xadj[i+1]) {
last_unmatched = gk_max(ii, last_unmatched)+1;
for (; last_unmatched<nvtxs; last_unmatched++) {
k = perm[last_unmatched];
if (match[k] == UNMATCHED && myhome[i] == myhome[k]) {
match[i] = firstvtx+k + (i <= k ? KEEP_BIT : 0);
match[k] = firstvtx+i + (i > k ? KEEP_BIT : 0);
changed[nchanged++] = i;
changed[nchanged++] = k;
break;
}
}
continue;
}
/* Find a heavy-edge matching. */
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = adjncy[j];
if (match[k] == UNMATCHED && myhome[k] == myhome[i]) {
if (ncon == 1) {
if (maxi == -1 || adjwgt[maxi] < adjwgt[j] ||
(adjwgt[maxi] == adjwgt[j] && RandomInRange(xadj[i+1]-xadj[i]) == 0)) {
maxi = j;
maxidx = k;
}
}
else {
if (maxi == -1 || adjwgt[maxi] < adjwgt[j] ||
(adjwgt[maxi] == adjwgt[j] && maxidx < nvtxs && k < nvtxs &&
BetterVBalance(ncon,nvwgt+i*ncon,nvwgt+maxidx*ncon,nvwgt+k*ncon) >= 0)) {
maxi = j;
maxidx = k;
}
}
}
}
if (maxi != -1) {
k = adjncy[maxi];
if (k < nvtxs) { /* Take care the local vertices first */
/* Here we give preference the local matching by granting it right away */
match[i] = firstvtx+k + (i <= k ? KEEP_BIT : 0);
match[k] = firstvtx+i + (i > k ? KEEP_BIT : 0);
changed[nchanged++] = i;
changed[nchanged++] = k;
}
else { /* Take care any remote boundary vertices */
match[k] = MAYBE_MATCHED;
/* Alternate among which vertices will issue the requests */
if ((wside == 0 && firstvtx+i < graph->imap[k]) ||
(wside == 1 && firstvtx+i > graph->imap[k])) {
match[i] = MAYBE_MATCHED;
match_requests[nrequests].key = graph->imap[k];
match_requests[nrequests].val = firstvtx+i;
nrequests++;
}
}
}
}
}
#ifdef DEBUG_MATCH
PrintVector2(ctrl, nvtxs, firstvtx, match, "Match1");
myprintf(ctrl, "[c: %2"PRIDX"] Nlocal: %"PRIDX", Nrequests: %"PRIDX"\n", c, nlocal, nrequests);
#endif
/***********************************************************
* Exchange the match_requests, requests for me are stored in
* match_granted
************************************************************/
/* Issue the receives first. Note that from each PE can receive a maximum
of the interface node that it needs to send it in the case of a mat-vec */
for (i=0; i<nnbrs; i++) {
gkMPI_Irecv((void *)(match_granted+recvptr[i]), 2*(recvptr[i+1]-recvptr[i]), IDX_T,
peind[i], 1, ctrl->comm, ctrl->rreq+i);
}
/* Issue the sends next. This needs some work */
ikvsorti(nrequests, match_requests);
for (j=i=0; i<nnbrs; i++) {
otherlastvtx = vtxdist[peind[i]+1];
for (k=j; k<nrequests && match_requests[k].key < otherlastvtx; k++);
gkMPI_Isend((void *)(match_requests+j), 2*(k-j), IDX_T, peind[i], 1,
ctrl->comm, ctrl->sreq+i);
j = k;
}
/* OK, now get into the loop waiting for the operations to finish */
gkMPI_Waitall(nnbrs, ctrl->rreq, ctrl->statuses);
for (i=0; i<nnbrs; i++) {
gkMPI_Get_count(ctrl->statuses+i, IDX_T, nreqs_pe+i);
nreqs_pe[i] = nreqs_pe[i]/2; /* Adjust for pairs of IDX_T */
}
gkMPI_Waitall(nnbrs, ctrl->sreq, ctrl->statuses);
/***********************************************************
* Now, go and service the requests that you received in
* match_granted
************************************************************/
RandomPermute(nnbrs, nperm, 0);
for (ii=0; ii<nnbrs; ii++) {
i = nperm[ii];
pe_requests = match_granted+recvptr[i];
for (j=0; j<nreqs_pe[i]; j++) {
k = pe_requests[j].key;
PASSERTP(ctrl, k >= firstvtx && k < lastvtx, (ctrl, "%"PRIDX" %"PRIDX" %"PRIDX" %"PRIDX" %"PRIDX"\n", firstvtx, lastvtx, k, j, peind[i]));
/* myprintf(ctrl, "Requesting a match %"PRIDX" %"PRIDX"\n", pe_requests[j].key, pe_requests[j].val); */
if (match[k-firstvtx] == UNMATCHED) { /* Bingo, lets grant this request */
changed[nchanged++] = k-firstvtx;
if (nkept >= 0) { /* decide who to keep it based on local balance */
match[k-firstvtx] = pe_requests[j].val + KEEP_BIT;
nkept--;
}
else {
match[k-firstvtx] = pe_requests[j].val;
pe_requests[j].key += KEEP_BIT;
nkept++;
}
/* myprintf(ctrl, "Request from pe:%"PRIDX" (%"PRIDX" %"PRIDX") granted!\n", peind[i], pe_requests[j].val, pe_requests[j].key); */
}
else { /* We are not granting the request */
/* myprintf(ctrl, "Request from pe:%"PRIDX" (%"PRIDX" %"PRIDX") not granted!\n", peind[i], pe_requests[j].val, pe_requests[j].key); */
pe_requests[j].key = UNMATCHED;
}
}
}
/***********************************************************
* Exchange the match_granted information. It is stored in
* match_requests
************************************************************/
/* Issue the receives first. Note that from each PE can receive a maximum
of the interface node that it needs to send during the case of a mat-vec */
for (i=0; i<nnbrs; i++) {
gkMPI_Irecv((void *)(match_requests+sendptr[i]), 2*(sendptr[i+1]-sendptr[i]), IDX_T,
peind[i], 1, ctrl->comm, ctrl->rreq+i);
}
/* Issue the sends next. */
for (i=0; i<nnbrs; i++) {
gkMPI_Isend((void *)(match_granted+recvptr[i]), 2*nreqs_pe[i], IDX_T,
peind[i], 1, ctrl->comm, ctrl->sreq+i);
}
/* OK, now get into the loop waiting for the operations to finish */
gkMPI_Waitall(nnbrs, ctrl->rreq, ctrl->statuses);
for (i=0; i<nnbrs; i++) {
gkMPI_Get_count(ctrl->statuses+i, IDX_T, nreqs_pe+i);
nreqs_pe[i] = nreqs_pe[i]/2; /* Adjust for pairs of IDX_T */
}
gkMPI_Waitall(nnbrs, ctrl->sreq, ctrl->statuses);
/***********************************************************
* Now, go and through the match_requests and update local
* match information for the matchings that were granted.
************************************************************/
for (i=0; i<nnbrs; i++) {
pe_requests = match_requests+sendptr[i];
for (j=0; j<nreqs_pe[i]; j++) {
match[pe_requests[j].val-firstvtx] = pe_requests[j].key;
if (pe_requests[j].key != UNMATCHED)
changed[nchanged++] = pe_requests[j].val-firstvtx;
}
}
for (i=0; i<nchanged; i++) {
ii = iperm[changed[i]];
perm[ii] = perm[nmatched];
iperm[perm[nmatched]] = ii;
nmatched++;
}
CommChangedInterfaceData(ctrl, graph, nchanged, changed, match,
match_requests, match_granted);
}
/* Traverse the vertices and those that were unmatched, match them with themselves */
cnvtxs = 0;
for (i=0; i<nvtxs; i++) {
if (match[i] == UNMATCHED || match[i] == TOO_HEAVY) {
match[i] = (firstvtx+i) + KEEP_BIT;
cnvtxs++;
}
else if (match[i] >= KEEP_BIT) { /* A matched vertex which I get to keep */
cnvtxs++;
}
}
if (ctrl->dbglvl&DBG_MATCHINFO) {
PrintVector2(ctrl, nvtxs, firstvtx, match, "Match");
myprintf(ctrl, "Cnvtxs: %"PRIDX"\n", cnvtxs);
rprintf(ctrl, "Done with matching...\n");
}
WCOREPOP;
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->comm));
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ContractTmr));
CreateCoarseGraph_Global(ctrl, graph, cnvtxs);
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->comm));
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ContractTmr));
}
void EliminateComponents(ctrl_t *ctrl, graph_t *graph) {
idx_t i, ii, j, jj, k, me, nparts, nvtxs, ncon, ncmps, other,
ncand, target;
idx_t *xadj, *adjncy, *vwgt, *adjwgt, *where, *pwgts;
idx_t *cptr, *cind, *cpvec, *pcptr, *pcind, *cwhere;
idx_t cid, bestcid, *cwgt, *bestcwgt;
idx_t ntodo, oldntodo, *todo;
rkv_t *cand;
real_t *tpwgts;
idx_t *vmarker = NULL, *pmarker = NULL, *modind = NULL; /* volume specific work arrays */
WCOREPUSH;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
adjncy = graph->adjncy;
vwgt = graph->vwgt;
adjwgt = (ctrl->objtype == METIS_OBJTYPE_VOL ? NULL : graph->adjwgt);
where = graph->where;
pwgts = graph->pwgts;
nparts = ctrl->nparts;
tpwgts = ctrl->tpwgts;
cptr = iwspacemalloc(ctrl, nvtxs + 1);
cind = iwspacemalloc(ctrl, nvtxs);
ncmps = FindPartitionInducedComponents(graph, where, cptr, cind);
IFSET(ctrl->dbglvl, METIS_DBG_CONTIGINFO,
printf("I found %"PRIDX" components, for this %"PRIDX"-way partition\n",
ncmps, nparts));
/* There are more components than partitions */
if (ncmps > nparts) {
cwgt = iwspacemalloc(ctrl, ncon);
bestcwgt = iwspacemalloc(ctrl, ncon);
cpvec = iwspacemalloc(ctrl, nparts);
pcptr = iset(nparts + 1, 0, iwspacemalloc(ctrl, nparts + 1));
pcind = iwspacemalloc(ctrl, ncmps);
cwhere = iset(nvtxs, -1, iwspacemalloc(ctrl, nvtxs));
todo = iwspacemalloc(ctrl, ncmps);
cand = (rkv_t *) wspacemalloc(ctrl, nparts * sizeof(rkv_t));
if (ctrl->objtype == METIS_OBJTYPE_VOL) {
/* Vol-refinement specific working arrays */
modind = iwspacemalloc(ctrl, nvtxs);
vmarker = iset(nvtxs, 0, iwspacemalloc(ctrl, nvtxs));
pmarker = iset(nparts, -1, iwspacemalloc(ctrl, nparts));
}
/* Get a CSR representation of the components-2-partitions mapping */
for (i = 0; i < ncmps; i++) {
pcptr[where[cind[cptr[i]]]]++;
}
MAKECSR(i, nparts, pcptr);
for (i = 0; i < ncmps; i++) {
pcind[pcptr[where[cind[cptr[i]]]]++] = i;
}
SHIFTCSR(i, nparts, pcptr);
/* Assign the heaviest component of each partition to its original partition */
for (ntodo = 0, i = 0; i < nparts; i++) {
if (pcptr[i + 1] - pcptr[i] == 1) {
bestcid = pcind[pcptr[i]];
} else {
for (bestcid = -1, j = pcptr[i]; j < pcptr[i + 1]; j++) {
cid = pcind[j];
iset(ncon, 0, cwgt);
for (ii = cptr[cid]; ii < cptr[cid + 1]; ii++) {
iaxpy(ncon, 1, vwgt + cind[ii] * ncon, 1, cwgt, 1);
}
if (bestcid == -1 || isum(ncon, bestcwgt, 1) < isum(ncon, cwgt, 1)) {
bestcid = cid;
icopy(ncon, cwgt, bestcwgt);
}
}
/* Keep track of those that need to be dealt with */
for (j = pcptr[i]; j < pcptr[i + 1]; j++) {
if (pcind[j] != bestcid) {
todo[ntodo++] = pcind[j];
}
}
}
for (j = cptr[bestcid]; j < cptr[bestcid + 1]; j++) {
ASSERT(where[cind[j]] == i);
cwhere[cind[j]] = i;
}
}
while (ntodo > 0) {
oldntodo = ntodo;
for (i = 0; i < ntodo; i++) {
cid = todo[i];
me = where[cind[cptr[cid]]]; /* Get the domain of this component */
/* Determine the weight of the block to be moved */
iset(ncon, 0, cwgt);
for (j = cptr[cid]; j < cptr[cid + 1]; j++) {
iaxpy(ncon, 1, vwgt + cind[j] * ncon, 1, cwgt, 1);
}
IFSET(ctrl->dbglvl, METIS_DBG_CONTIGINFO,
printf("Trying to move %"PRIDX" [%"PRIDX"] from %"PRIDX"\n",
cid, isum(ncon, cwgt, 1), me));
/* Determine the connectivity */
iset(nparts, 0, cpvec);
for (j = cptr[cid]; j < cptr[cid + 1]; j++) {
ii = cind[j];
for (jj = xadj[ii]; jj < xadj[ii + 1]; jj++) {
if (cwhere[adjncy[jj]] != -1) {
cpvec[cwhere[adjncy[jj]]] += (adjwgt ? adjwgt[jj] : 1);
}
}
}
/* Put the neighbors into a cand[] array for sorting */
for (ncand = 0, j = 0; j < nparts; j++) {
if (cpvec[j] > 0) {
cand[ncand].key = cpvec[j];
cand[ncand++].val = j;
}
}
if (ncand == 0) {
continue;
}
rkvsortd(ncand, cand);
/* Limit the moves to only the top candidates, which are defined as
those with connectivity at least 50% of the best.
This applies only when ncon=1, as for multi-constraint, balancing
will be hard. */
if (ncon == 1) {
for (j = 1; j < ncand; j++) {
if (cand[j].key < .5 * cand[0].key) {
break;
}
}
ncand = j;
}
/* Now among those, select the one with the best balance */
target = cand[0].val;
for (j = 1; j < ncand; j++) {
if (BetterBalanceKWay(ncon, cwgt, ctrl->ubfactors,
1, pwgts + target * ncon, ctrl->pijbm + target * ncon,
1, pwgts + cand[j].val * ncon, ctrl->pijbm + cand[j].val * ncon)) {
target = cand[j].val;
}
}
IFSET(ctrl->dbglvl, METIS_DBG_CONTIGINFO,
printf("\tMoving it to %"PRIDX" [%"PRIDX"] [%"PRIDX"]\n", target, cpvec[target], ncand));
/* Note that as a result of a previous movement, a connected component may
now will like to stay to its original partition */
if (target != me) {
switch (ctrl->objtype) {
case METIS_OBJTYPE_CUT:MoveGroupContigForCut(ctrl, graph, target, cid, cptr, cind);
break;
case METIS_OBJTYPE_VOL:
MoveGroupContigForVol(ctrl, graph, target, cid, cptr, cind,
vmarker, pmarker, modind);
break;
default:gk_errexit(SIGERR, "Unknown objtype %d\n", ctrl->objtype);
}
}
/* Update the cwhere vector */
for (j = cptr[cid]; j < cptr[cid + 1]; j++) {
cwhere[cind[j]] = target;
}
todo[i] = todo[--ntodo];
}
if (oldntodo == ntodo) {
IFSET(ctrl->dbglvl, METIS_DBG_CONTIGINFO, printf("Stopped at ntodo: %"PRIDX"\n", ntodo));
break;
}
}
for (i = 0; i < nvtxs; i++) {
ASSERT(where[i] == cwhere[i]);
}
}
WCOREPOP;
}
void EliminateSubDomainEdges(ctrl_t *ctrl, graph_t *graph)
{
idx_t i, ii, j, k, ncon, nparts, scheme, pid_from, pid_to, me, other, nvtxs,
total, max, avg, totalout, nind=0, ncand=0, ncand2, target, target2,
nadd, bestnadd=0;
idx_t min, move, *cpwgt;
idx_t *xadj, *adjncy, *vwgt, *adjwgt, *pwgts, *where, *maxpwgt,
*mypmat, *otherpmat, *kpmat, *ind;
idx_t *nads, **adids, **adwgts;
ikv_t *cand, *cand2;
ipq_t queue;
real_t *tpwgts, badfactor=1.4;
idx_t *pptr, *pind;
idx_t *vmarker=NULL, *pmarker=NULL, *modind=NULL; /* volume specific work arrays */
WCOREPUSH;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
adjncy = graph->adjncy;
vwgt = graph->vwgt;
adjwgt = (ctrl->objtype == METIS_OBJTYPE_VOL ? NULL : graph->adjwgt);
where = graph->where;
pwgts = graph->pwgts; /* We assume that this is properly initialized */
nparts = ctrl->nparts;
tpwgts = ctrl->tpwgts;
cpwgt = iwspacemalloc(ctrl, ncon);
maxpwgt = iwspacemalloc(ctrl, nparts*ncon);
ind = iwspacemalloc(ctrl, nvtxs);
otherpmat = iset(nparts, 0, iwspacemalloc(ctrl, nparts));
cand = ikvwspacemalloc(ctrl, nparts);
cand2 = ikvwspacemalloc(ctrl, nparts);
pptr = iwspacemalloc(ctrl, nparts+1);
pind = iwspacemalloc(ctrl, nvtxs);
iarray2csr(nvtxs, nparts, where, pptr, pind);
if (ctrl->objtype == METIS_OBJTYPE_VOL) {
/* Vol-refinement specific working arrays */
modind = iwspacemalloc(ctrl, nvtxs);
vmarker = iset(nvtxs, 0, iwspacemalloc(ctrl, nvtxs));
pmarker = iset(nparts, -1, iwspacemalloc(ctrl, nparts));
}
/* Compute the pmat matrix and ndoms */
ComputeSubDomainGraph(ctrl, graph);
nads = ctrl->nads;
adids = ctrl->adids;
adwgts = ctrl->adwgts;
mypmat = iset(nparts, 0, ctrl->pvec1);
kpmat = iset(nparts, 0, ctrl->pvec2);
/* Compute the maximum allowed weight for each domain */
for (i=0; i<nparts; i++) {
for (j=0; j<ncon; j++)
maxpwgt[i*ncon+j] =
(ncon == 1 ? 1.25 : 1.025)*tpwgts[i]*graph->tvwgt[j]*ctrl->ubfactors[j];
}
ipqInit(&queue, nparts);
/* Get into the loop eliminating subdomain connections */
while (1) {
total = isum(nparts, nads, 1);
avg = total/nparts;
max = nads[iargmax(nparts, nads)];
IFSET(ctrl->dbglvl, METIS_DBG_CONNINFO,
printf("Adjacent Subdomain Stats: Total: %3"PRIDX", "
"Max: %3"PRIDX"[%zu], Avg: %3"PRIDX"\n",
total, max, iargmax(nparts, nads), avg));
if (max < badfactor*avg)
break;
/* Add the subdomains that you will try to reduce their connectivity */
ipqReset(&queue);
for (i=0; i<nparts; i++) {
if (nads[i] >= avg + (max-avg)/2)
ipqInsert(&queue, i, nads[i]);
}
move = 0;
while ((me = ipqGetTop(&queue)) != -1) {
totalout = isum(nads[me], adwgts[me], 1);
for (ncand2=0, i=0; i<nads[me]; i++) {
mypmat[adids[me][i]] = adwgts[me][i];
/* keep track of the weakly connected adjacent subdomains */
if (2*nads[me]*adwgts[me][i] < totalout) {
cand2[ncand2].val = adids[me][i];
cand2[ncand2++].key = adwgts[me][i];
}
}
IFSET(ctrl->dbglvl, METIS_DBG_CONNINFO,
printf("Me: %"PRIDX", Degree: %4"PRIDX", TotalOut: %"PRIDX",\n",
me, nads[me], totalout));
/* Sort the connections according to their cut */
ikvsorti(ncand2, cand2);
/* Two schemes are used for eliminating subdomain edges.
The first, tries to eliminate subdomain edges by moving remote groups
of vertices to subdomains that 'me' is already connected to.
The second, tries to eliminate subdomain edges by moving entire sets of
my vertices that connect to the 'other' subdomain to a subdomain that
I'm already connected to.
These two schemes are applied in sequence. */
target = target2 = -1;
for (scheme=0; scheme<2; scheme++) {
for (min=0; min<ncand2; min++) {
other = cand2[min].val;
/* pid_from is the subdomain from where the vertices will be removed.
pid_to is the adjacent subdomain to pid_from that defines the
(me, other) subdomain edge that needs to be removed */
if (scheme == 0) {
pid_from = other;
pid_to = me;
}
else {
pid_from = me;
pid_to = other;
}
/* Go and find the vertices in 'other' that are connected in 'me' */
for (nind=0, ii=pptr[pid_from]; ii<pptr[pid_from+1]; ii++) {
i = pind[ii];
ASSERT(where[i] == pid_from);
for (j=xadj[i]; j<xadj[i+1]; j++) {
if (where[adjncy[j]] == pid_to) {
ind[nind++] = i;
break;
}
}
}
/* Go and construct the otherpmat to see where these nind vertices are
connected to */
iset(ncon, 0, cpwgt);
for (ncand=0, ii=0; ii<nind; ii++) {
i = ind[ii];
iaxpy(ncon, 1, vwgt+i*ncon, 1, cpwgt, 1);
for (j=xadj[i]; j<xadj[i+1]; j++) {
if ((k = where[adjncy[j]]) == pid_from)
continue;
if (otherpmat[k] == 0)
cand[ncand++].val = k;
otherpmat[k] += (adjwgt ? adjwgt[j] : 1);
}
}
for (i=0; i<ncand; i++) {
cand[i].key = otherpmat[cand[i].val];
ASSERT(cand[i].key > 0);
}
ikvsortd(ncand, cand);
IFSET(ctrl->dbglvl, METIS_DBG_CONNINFO,
printf("\tMinOut: %4"PRIDX", to: %3"PRIDX", TtlWgt: %5"PRIDX"[#:%"PRIDX"]\n",
mypmat[other], other, isum(ncon, cpwgt, 1), nind));
/* Go through and select the first domain that is common with 'me', and does
not increase the nads[target] higher than nads[me], subject to the maxpwgt
constraint. Traversal is done from the mostly connected to the least. */
for (i=0; i<ncand; i++) {
k = cand[i].val;
if (mypmat[k] > 0) {
/* Check if balance will go off */
if (!ivecaxpylez(ncon, 1, cpwgt, pwgts+k*ncon, maxpwgt+k*ncon))
continue;
/* get a dense vector out of k's connectivity */
for (j=0; j<nads[k]; j++)
kpmat[adids[k][j]] = adwgts[k][j];
/* Check if the move to domain k will increase the nads of another
subdomain j that the set of vertices being moved are connected
to but domain k is not connected to. */
for (j=0; j<nparts; j++) {
if (otherpmat[j] > 0 && kpmat[j] == 0 && nads[j]+1 >= nads[me])
break;
}
/* There were no bad second level effects. See if you can find a
subdomain to move to. */
if (j == nparts) {
for (nadd=0, j=0; j<nparts; j++) {
if (otherpmat[j] > 0 && kpmat[j] == 0)
nadd++;
}
IFSET(ctrl->dbglvl, METIS_DBG_CONNINFO,
printf("\t\tto=%"PRIDX", nadd=%"PRIDX", %"PRIDX"\n", k, nadd, nads[k]));
if (nads[k]+nadd < nads[me]) {
if (target2 == -1 || nads[target2]+bestnadd > nads[k]+nadd ||
(nads[target2]+bestnadd == nads[k]+nadd && bestnadd > nadd)) {
target2 = k;
bestnadd = nadd;
}
}
if (nadd == 0)
target = k;
}
/* reset kpmat for the next iteration */
for (j=0; j<nads[k]; j++)
kpmat[adids[k][j]] = 0;
}
if (target != -1)
break;
}
/* reset the otherpmat for the next iteration */
for (i=0; i<ncand; i++)
otherpmat[cand[i].val] = 0;
if (target == -1 && target2 != -1)
target = target2;
if (target != -1) {
IFSET(ctrl->dbglvl, METIS_DBG_CONNINFO,
printf("\t\tScheme: %"PRIDX". Moving to %"PRIDX"\n", scheme, target));
move = 1;
break;
}
}
if (target != -1)
break; /* A move was found. No need to try the other scheme */
}
/* reset the mypmat for next iteration */
for (i=0; i<nads[me]; i++)
mypmat[adids[me][i]] = 0;
/* Note that once a target is found the above loops exit right away. So the
following variables are valid */
if (target != -1) {
switch (ctrl->objtype) {
case METIS_OBJTYPE_CUT:
MoveGroupMinConnForCut(ctrl, graph, target, nind, ind);
break;
case METIS_OBJTYPE_VOL:
MoveGroupMinConnForVol(ctrl, graph, target, nind, ind, vmarker,
pmarker, modind);
break;
default:
gk_errexit(SIGERR, "Unknown objtype of %d\n", ctrl->objtype);
}
/* Update the csr representation of the partitioning vector */
iarray2csr(nvtxs, nparts, where, pptr, pind);
}
}
if (move == 0)
break;
}
ipqFree(&queue);
WCOREPOP;
}
/*************************************************************************
* This function is the entry point of the initial partitioning algorithm.
* This algorithm assembles the graph to all the processors and preceed
* serially.
**************************************************************************/
idx_t Mc_Diffusion(ctrl_t *ctrl, graph_t *graph, idx_t *vtxdist, idx_t *where,
idx_t *home, idx_t npasses)
{
idx_t h, i, j;
idx_t nvtxs, nedges, ncon, pass, iter, domain, processor;
idx_t nparts, mype, npes, nlinks, me, you, wsize;
idx_t nvisited, nswaps = -1, tnswaps, done, alldone = -1;
idx_t *rowptr, *colind, *diff_where, *sr_where, *ehome, *map, *rmap;
idx_t *pack, *unpack, *match, *proc2sub, *sub2proc;
idx_t *visited, *gvisited;
real_t *transfer, *npwgts, maxdiff, minflow, maxflow;
real_t lbavg, oldlbavg, ubavg, *lbvec;
real_t *diff_flows, *sr_flows;
real_t diff_lbavg, sr_lbavg, diff_cost, sr_cost;
idx_t *rbuffer, *sbuffer;
idx_t *rcount, *rdispl;
real_t *solution, *load, *workspace;
matrix_t matrix;
graph_t *egraph;
if (graph->ncon > 3)
return 0;
WCOREPUSH;
nvtxs = graph->nvtxs;
nedges = graph->nedges;
ncon = graph->ncon;
nparts = ctrl->nparts;
mype = ctrl->mype;
npes = ctrl->npes;
ubavg = ravg(ncon, ctrl->ubvec);
/* initialize variables and allocate memory */
lbvec = rwspacemalloc(ctrl, ncon);
diff_flows = rwspacemalloc(ctrl, ncon);
sr_flows = rwspacemalloc(ctrl, ncon);
load = rwspacemalloc(ctrl, nparts);
solution = rwspacemalloc(ctrl, nparts);
npwgts = graph->gnpwgts = rwspacemalloc(ctrl, ncon*nparts);
matrix.values = rwspacemalloc(ctrl, nedges);
transfer = matrix.transfer = rwspacemalloc(ctrl, ncon*nedges);
proc2sub = iwspacemalloc(ctrl, gk_max(nparts, npes*2));
sub2proc = iwspacemalloc(ctrl, nparts);
match = iwspacemalloc(ctrl, nparts);
rowptr = matrix.rowptr = iwspacemalloc(ctrl, nparts+1);
colind = matrix.colind = iwspacemalloc(ctrl, nedges);
rcount = iwspacemalloc(ctrl, npes);
rdispl = iwspacemalloc(ctrl, npes+1);
pack = iwspacemalloc(ctrl, nvtxs);
unpack = iwspacemalloc(ctrl, nvtxs);
rbuffer = iwspacemalloc(ctrl, nvtxs);
sbuffer = iwspacemalloc(ctrl, nvtxs);
map = iwspacemalloc(ctrl, nvtxs);
rmap = iwspacemalloc(ctrl, nvtxs);
diff_where = iwspacemalloc(ctrl, nvtxs);
ehome = iwspacemalloc(ctrl, nvtxs);
wsize = gk_max(sizeof(real_t)*nparts*6, sizeof(idx_t)*(nvtxs+nparts*2+1));
workspace = (real_t *)gk_malloc(wsize, "Mc_Diffusion: workspace");
graph->ckrinfo = (ckrinfo_t *)gk_malloc(nvtxs*sizeof(ckrinfo_t), "Mc_Diffusion: rinfo");
/* construct subdomain connectivity graph */
matrix.nrows = nparts;
SetUpConnectGraph(graph, &matrix, (idx_t *)workspace);
nlinks = (matrix.nnzs-nparts) / 2;
visited = iwspacemalloc(ctrl, matrix.nnzs);
gvisited = iwspacemalloc(ctrl, matrix.nnzs);
for (pass=0; pass<npasses; pass++) {
rset(matrix.nnzs*ncon, 0.0, transfer);
iset(matrix.nnzs, 0, gvisited);
iset(matrix.nnzs, 0, visited);
iter = nvisited = 0;
/* compute ncon flow solutions */
for (h=0; h<ncon; h++) {
rset(nparts, 0.0, solution);
ComputeLoad(graph, nparts, load, ctrl->tpwgts, h);
lbvec[h] = (rmax(nparts, load)+1.0/nparts) * (real_t)nparts;
ConjGrad2(&matrix, load, solution, 0.001, workspace);
ComputeTransferVector(ncon, &matrix, solution, transfer, h);
}
oldlbavg = ravg(ncon, lbvec);
tnswaps = 0;
maxdiff = 0.0;
for (i=0; i<nparts; i++) {
for (j=rowptr[i]; j<rowptr[i+1]; j++) {
maxflow = rmax(ncon, transfer+j*ncon);
minflow = rmin(ncon, transfer+j*ncon);
maxdiff = (maxflow - minflow > maxdiff) ? maxflow - minflow : maxdiff;
}
}
while (nvisited < nlinks) {
/* compute independent sets of subdomains */
iset(gk_max(nparts, npes*2), UNMATCHED, proc2sub);
CSR_Match_SHEM(&matrix, match, proc2sub, gvisited, ncon);
/* set up the packing arrays */
iset(nparts, UNMATCHED, sub2proc);
for (i=0; i<npes*2; i++) {
if (proc2sub[i] == UNMATCHED)
break;
sub2proc[proc2sub[i]] = i/2;
}
iset(npes, 0, rcount);
for (i=0; i<nvtxs; i++) {
domain = where[i];
processor = sub2proc[domain];
if (processor != UNMATCHED)
rcount[processor]++;
}
rdispl[0] = 0;
for (i=1; i<npes+1; i++)
rdispl[i] = rdispl[i-1] + rcount[i-1];
iset(nvtxs, UNMATCHED, unpack);
for (i=0; i<nvtxs; i++) {
domain = where[i];
processor = sub2proc[domain];
if (processor != UNMATCHED)
unpack[rdispl[processor]++] = i;
}
SHIFTCSR(i, npes, rdispl);
iset(nvtxs, UNMATCHED, pack);
for (i=0; i<rdispl[npes]; i++) {
ASSERT(unpack[i] != UNMATCHED);
domain = where[unpack[i]];
processor = sub2proc[domain];
if (processor != UNMATCHED)
pack[unpack[i]] = i;
}
/* Compute the flows */
if (proc2sub[mype*2] != UNMATCHED) {
me = proc2sub[2*mype];
you = proc2sub[2*mype+1];
ASSERT(me != you);
for (j=rowptr[me]; j<rowptr[me+1]; j++) {
if (colind[j] == you) {
visited[j] = 1;
rcopy(ncon, transfer+j*ncon, diff_flows);
break;
}
}
for (j=rowptr[you]; j<rowptr[you+1]; j++) {
if (colind[j] == me) {
visited[j] = 1;
for (h=0; h<ncon; h++) {
if (transfer[j*ncon+h] > 0.0)
diff_flows[h] = -1.0 * transfer[j*ncon+h];
}
break;
}
}
nswaps = 1;
rcopy(ncon, diff_flows, sr_flows);
iset(nvtxs, 0, sbuffer);
for (i=0; i<nvtxs; i++) {
if (where[i] == me || where[i] == you)
sbuffer[i] = 1;
}
egraph = ExtractGraph(ctrl, graph, sbuffer, map, rmap);
if (egraph != NULL) {
icopy(egraph->nvtxs, egraph->where, diff_where);
for (j=0; j<egraph->nvtxs; j++)
ehome[j] = home[map[j]];
RedoMyLink(ctrl, egraph, ehome, me, you, sr_flows, &sr_cost, &sr_lbavg);
if (ncon <= 4) {
sr_where = egraph->where;
egraph->where = diff_where;
nswaps = BalanceMyLink(ctrl, egraph, ehome, me, you, diff_flows, maxdiff,
&diff_cost, &diff_lbavg, 1.0/(real_t)nvtxs);
if ((sr_lbavg < diff_lbavg &&
(diff_lbavg >= ubavg-1.0 || sr_cost == diff_cost)) ||
(sr_lbavg < ubavg-1.0 && sr_cost < diff_cost)) {
for (i=0; i<egraph->nvtxs; i++)
where[map[i]] = sr_where[i];
}
else {
for (i=0; i<egraph->nvtxs; i++)
where[map[i]] = diff_where[i];
}
}
else {
for (i=0; i<egraph->nvtxs; i++)
where[map[i]] = egraph->where[i];
}
gk_free((void **)&egraph->xadj, &egraph->nvwgt, &egraph->adjncy, &egraph, LTERM);
}
/* Pack the flow data */
iset(nvtxs, UNMATCHED, sbuffer);
for (i=0; i<nvtxs; i++) {
domain = where[i];
if (domain == you || domain == me)
sbuffer[pack[i]] = where[i];
}
}
/* Broadcast the flow data */
gkMPI_Allgatherv((void *)&sbuffer[rdispl[mype]], rcount[mype], IDX_T,
(void *)rbuffer, rcount, rdispl, IDX_T, ctrl->comm);
/* Unpack the flow data */
for (i=0; i<rdispl[npes]; i++) {
if (rbuffer[i] != UNMATCHED)
where[unpack[i]] = rbuffer[i];
}
/* Do other stuff */
gkMPI_Allreduce((void *)visited, (void *)gvisited, matrix.nnzs,
IDX_T, MPI_MAX, ctrl->comm);
nvisited = isum(matrix.nnzs, gvisited, 1)/2;
tnswaps += GlobalSESum(ctrl, nswaps);
if (iter++ == NGD_PASSES)
break;
}
/* perform serial refinement */
Mc_ComputeSerialPartitionParams(ctrl, graph, nparts);
Mc_SerialKWayAdaptRefine(ctrl, graph, nparts, home, ctrl->ubvec, 10);
/* check for early breakout */
for (h=0; h<ncon; h++) {
lbvec[h] = (real_t)(nparts) *
npwgts[rargmax_strd(nparts,npwgts+h,ncon)*ncon+h];
}
lbavg = ravg(ncon, lbvec);
done = 0;
if (tnswaps == 0 || lbavg >= oldlbavg || lbavg <= ubavg + 0.035)
done = 1;
alldone = GlobalSEMax(ctrl, done);
if (alldone == 1)
break;
}
/* ensure that all subdomains have at least one vertex */
/*
iset(nparts, 0, match);
for (i=0; i<nvtxs; i++)
match[where[i]]++;
done = 0;
while (done == 0) {
done = 1;
me = iargmin(nparts, match);
if (match[me] == 0) {
if (ctrl->mype == PE) printf("WARNING: empty subdomain %"PRIDX" in Mc_Diffusion\n", me);
you = iargmax(nparts, match);
for (i=0; i<nvtxs; i++) {
if (where[i] == you) {
where[i] = me;
match[you]--;
match[me]++;
done = 0;
break;
}
}
}
}
*/
/* now free memory and return */
gk_free((void **)&workspace, (void **)&graph->ckrinfo, LTERM);
graph->gnpwgts = NULL;
graph->ckrinfo = NULL;
WCOREPOP;
return 0;
}
void FM_Mc2WayCutRefine(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts, idx_t niter)
{
idx_t i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass,
me, limit, tmp, cnum;
idx_t *xadj, *adjncy, *vwgt, *adjwgt, *pwgts, *where, *id, *ed,
*bndptr, *bndind;
idx_t *moved, *swaps, *perm, *qnum;
idx_t higain, mincut, initcut, newcut, mincutorder;
real_t *invtvwgt, *ubfactors, *minbalv, *newbalv;
real_t origbal, minbal, newbal, rgain, ffactor;
rpq_t **queues;
WCOREPUSH;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
invtvwgt = graph->invtvwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
pwgts = graph->pwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
moved = iwspacemalloc(ctrl, nvtxs);
swaps = iwspacemalloc(ctrl, nvtxs);
perm = iwspacemalloc(ctrl, nvtxs);
qnum = iwspacemalloc(ctrl, nvtxs);
ubfactors = rwspacemalloc(ctrl, ncon);
newbalv = rwspacemalloc(ctrl, ncon);
minbalv = rwspacemalloc(ctrl, ncon);
limit = gk_min(gk_max(0.01*nvtxs, 25), 150);
/* Determine a fudge factor to allow the refinement routines to get out
of tight balancing constraints. */
ffactor = .5/gk_max(20, nvtxs);
/* Initialize the queues */
queues = (rpq_t **)wspacemalloc(ctrl, 2*ncon*sizeof(rpq_t *));
for (i=0; i<2*ncon; i++)
queues[i] = rpqCreate(nvtxs);
for (i=0; i<nvtxs; i++)
qnum[i] = iargmax_nrm(ncon, vwgt+i*ncon, invtvwgt);
/* Determine the unbalance tolerance for each constraint. The tolerance is
equal to the maximum of the original load imbalance and the user-supplied
allowed tolerance. The rationale behind this approach is to allow the
refinement routine to improve the cut, without having to worry about fixing
load imbalance problems. The load imbalance is addressed by the balancing
routines. */
origbal = ComputeLoadImbalanceDiffVec(graph, 2, ctrl->pijbm, ctrl->ubfactors, ubfactors);
for (i=0; i<ncon; i++)
ubfactors[i] = (ubfactors[i] > 0 ? ctrl->ubfactors[i]+ubfactors[i] : ctrl->ubfactors[i]);
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
Print2WayRefineStats(ctrl, graph, ntpwgts, origbal, -2));
iset(nvtxs, -1, moved);
for (pass=0; pass<niter; pass++) { /* Do a number of passes */
for (i=0; i<2*ncon; i++)
rpqReset(queues[i]);
mincutorder = -1;
newcut = mincut = initcut = graph->mincut;
minbal = ComputeLoadImbalanceDiffVec(graph, 2, ctrl->pijbm, ubfactors, minbalv);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert boundary nodes in the priority queues */
nbnd = graph->nbnd;
irandArrayPermute(nbnd, perm, nbnd/5, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(ed[i] > 0 || id[i] == 0);
ASSERT(bndptr[i] != -1);
//rgain = 1.0*(ed[i]-id[i])/sqrt(vwgt[i*ncon+qnum[i]]+1);
//rgain = (ed[i]-id[i] > 0 ? 1.0*(ed[i]-id[i])/sqrt(vwgt[i*ncon+qnum[i]]+1) : ed[i]-id[i]);
rgain = ed[i]-id[i];
rpqInsert(queues[2*qnum[i]+where[i]], i, rgain);
}
for (nswaps=0; nswaps<nvtxs; nswaps++) {
SelectQueue(graph, ctrl->pijbm, ubfactors, queues, &from, &cnum);
to = (from+1)%2;
if (from == -1 || (higain = rpqGetTop(queues[2*cnum+from])) == -1)
break;
ASSERT(bndptr[higain] != -1);
newcut -= (ed[higain]-id[higain]);
iaxpy(ncon, 1, vwgt+higain*ncon, 1, pwgts+to*ncon, 1);
iaxpy(ncon, -1, vwgt+higain*ncon, 1, pwgts+from*ncon, 1);
newbal = ComputeLoadImbalanceDiffVec(graph, 2, ctrl->pijbm, ubfactors, newbalv);
if ((newcut < mincut && newbal <= ffactor) ||
(newcut == mincut && (newbal < minbal ||
(newbal == minbal && BetterBalance2Way(ncon, minbalv, newbalv))))) {
mincut = newcut;
minbal = newbal;
mincutorder = nswaps;
rcopy(ncon, newbalv, minbalv);
}
else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
newcut += (ed[higain]-id[higain]);
iaxpy(ncon, 1, vwgt+higain*ncon, 1, pwgts+from*ncon, 1);
iaxpy(ncon, -1, vwgt+higain*ncon, 1, pwgts+to*ncon, 1);
break;
}
where[higain] = to;
moved[higain] = nswaps;
swaps[nswaps] = higain;
if (ctrl->dbglvl&METIS_DBG_MOVEINFO) {
printf("Moved%6"PRIDX" from %"PRIDX"(%"PRIDX") Gain:%5"PRIDX", "
"Cut:%5"PRIDX", NPwgts:", higain, from, cnum, ed[higain]-id[higain], newcut);
for (l=0; l<ncon; l++)
printf("(%.3"PRREAL" %.3"PRREAL")", pwgts[l]*invtvwgt[l], pwgts[ncon+l]*invtvwgt[l]);
printf(" %+.3"PRREAL" LB: %.3"PRREAL"(%+.3"PRREAL")\n",
minbal, ComputeLoadImbalance(graph, 2, ctrl->pijbm), newbal);
}
/**************************************************************
* Update the id[i]/ed[i] values of the affected nodes
***************************************************************/
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
/* Update its boundary information and queue position */
if (bndptr[k] != -1) { /* If k was a boundary vertex */
if (ed[k] == 0) { /* Not a boundary vertex any more */
BNDDelete(nbnd, bndind, bndptr, k);
if (moved[k] == -1) /* Remove it if in the queues */
rpqDelete(queues[2*qnum[k]+where[k]], k);
}
else { /* If it has not been moved, update its position in the queue */
if (moved[k] == -1) {
//rgain = 1.0*(ed[k]-id[k])/sqrt(vwgt[k*ncon+qnum[k]]+1);
//rgain = (ed[k]-id[k] > 0 ?
// 1.0*(ed[k]-id[k])/sqrt(vwgt[k*ncon+qnum[k]]+1) : ed[k]-id[k]);
rgain = ed[k]-id[k];
rpqUpdate(queues[2*qnum[k]+where[k]], k, rgain);
}
}
}
else {
if (ed[k] > 0) { /* It will now become a boundary vertex */
BNDInsert(nbnd, bndind, bndptr, k);
if (moved[k] == -1) {
//rgain = 1.0*(ed[k]-id[k])/sqrt(vwgt[k*ncon+qnum[k]]+1);
//rgain = (ed[k]-id[k] > 0 ?
// 1.0*(ed[k]-id[k])/sqrt(vwgt[k*ncon+qnum[k]]+1) : ed[k]-id[k]);
rgain = ed[k]-id[k];
rpqInsert(queues[2*qnum[k]+where[k]], k, rgain);
}
}
}
}
}
/****************************************************************
* Roll back computations
*****************************************************************/
for (i=0; i<nswaps; i++)
moved[swaps[i]] = -1; /* reset moved array */
for (nswaps--; nswaps>mincutorder; nswaps--) {
higain = swaps[nswaps];
to = where[higain] = (where[higain]+1)%2;
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
else if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
iaxpy(ncon, 1, vwgt+higain*ncon, 1, pwgts+to*ncon, 1);
iaxpy(ncon, -1, vwgt+higain*ncon, 1, pwgts+((to+1)%2)*ncon, 1);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
if (bndptr[k] != -1 && ed[k] == 0)
BNDDelete(nbnd, bndind, bndptr, k);
if (bndptr[k] == -1 && ed[k] > 0)
BNDInsert(nbnd, bndind, bndptr, k);
}
}
graph->mincut = mincut;
graph->nbnd = nbnd;
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
Print2WayRefineStats(ctrl, graph, ntpwgts, minbal, mincutorder));
if (mincutorder <= 0 || mincut == initcut)
break;
}
for (i=0; i<2*ncon; i++)
rpqDestroy(queues[i]);
WCOREPOP;
}
void GrowBisectionNode(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts,
idx_t niparts)
{
idx_t i, j, k, nvtxs, drain, nleft, first, last, pwgts[2], oneminpwgt,
onemaxpwgt, from, me, bestcut=0, icut, mincut, inbfs;
idx_t *xadj, *vwgt, *adjncy, *where, *bndind;
idx_t *queue, *touched, *gain, *bestwhere;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
// adjwgt = graph->adjwgt;
bestwhere = iwspacemalloc(ctrl, nvtxs);
queue = iwspacemalloc(ctrl, nvtxs);
touched = iwspacemalloc(ctrl, nvtxs);
onemaxpwgt = ctrl->ubfactors[0]*graph->tvwgt[0]*0.5;
oneminpwgt = (1.0/ctrl->ubfactors[0])*graph->tvwgt[0]*0.5;
/* Allocate refinement memory. Allocate sufficient memory for both edge and node */
graph->pwgts = imalloc(3, "GrowBisectionNode: pwgts");
graph->where = imalloc(nvtxs, "GrowBisectionNode: where");
graph->bndptr = imalloc(nvtxs, "GrowBisectionNode: bndptr");
graph->bndind = imalloc(nvtxs, "GrowBisectionNode: bndind");
graph->id = imalloc(nvtxs, "GrowBisectionNode: id");
graph->ed = imalloc(nvtxs, "GrowBisectionNode: ed");
graph->nrinfo = (nrinfo_t *)gk_malloc(nvtxs*sizeof(nrinfo_t), "GrowBisectionNode: nrinfo");
where = graph->where;
bndind = graph->bndind;
for (inbfs=0; inbfs<niparts; inbfs++) {
iset(nvtxs, 1, where);
iset(nvtxs, 0, touched);
pwgts[1] = graph->tvwgt[0];
pwgts[0] = 0;
queue[0] = irandInRange(nvtxs);
touched[queue[0]] = 1;
first = 0; last = 1;
nleft = nvtxs-1;
drain = 0;
/* Start the BFS from queue to get a partition */
for (;;) {
if (first == last) { /* Empty. Disconnected graph! */
if (nleft == 0 || drain)
break;
k = irandInRange(nleft);
for (i=0; i<nvtxs; i++) { /* select the kth untouched vertex */
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] < oneminpwgt) {
drain = 1;
continue;
}
where[i] = 0;
INC_DEC(pwgts[0], pwgts[1], vwgt[i]);
if (pwgts[1] <= onemaxpwgt)
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, ntpwgts);
FM_2WayRefine(ctrl, graph, ntpwgts, 4);
/* Construct and refine the vertex separator */
for (i=0; i<graph->nbnd; i++) {
j = bndind[i];
if (xadj[j+1]-xadj[j] > 0) /* ignore islands */
where[j] = 2;
}
Compute2WayNodePartitionParams(ctrl, graph);
FM_2WayNodeRefine2Sided(ctrl, graph, 1);
FM_2WayNodeRefine1Sided(ctrl, graph, 4);
/*
printf("ISep: [%"PRIDX" %"PRIDX" %"PRIDX" %"PRIDX"] %"PRIDX"\n",
inbfs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2], bestcut);
*/
if (inbfs == 0 || bestcut > graph->mincut) {
bestcut = graph->mincut;
icopy(nvtxs, where, bestwhere);
}
}
graph->mincut = bestcut;
icopy(nvtxs, bestwhere, where);
WCOREPOP;
}
void CreateCoarseGraph_Global(ctrl_t *ctrl, graph_t *graph, idx_t cnvtxs)
{
idx_t h, i, j, k, l, ii, jj, ll, nnbrs, nvtxs, nedges, ncon;
idx_t firstvtx, lastvtx, cfirstvtx, clastvtx, otherlastvtx;
idx_t npes=ctrl->npes, mype=ctrl->mype;
idx_t cnedges, nsend, nrecv, nkeepsize, nrecvsize, nsendsize, v, u;
idx_t *xadj, *adjncy, *adjwgt, *vwgt, *vsize, *vtxdist, *home, *where;
idx_t *match, *cmap;
idx_t *cxadj, *cadjncy, *cadjwgt, *cvwgt, *cvsize = NULL, *chome = NULL,
*cwhere = NULL, *cvtxdist;
idx_t *rsizes, *ssizes, *rlens, *slens, *rgraph, *sgraph, *perm;
idx_t *peind, *recvptr, *recvind;
real_t *nvwgt, *cnvwgt;
graph_t *cgraph;
ikv_t *scand, *rcand;
idx_t htable[LHTSIZE], htableidx[LHTSIZE];
WCOREPUSH;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
vwgt = graph->vwgt;
vsize = graph->vsize;
nvwgt = graph->nvwgt;
home = graph->home;
where = graph->where;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
match = graph->match;
vtxdist = graph->vtxdist;
firstvtx = vtxdist[mype];
lastvtx = vtxdist[mype+1];
cmap = graph->cmap = ismalloc(nvtxs+graph->nrecv, -1, "Global_CreateCoarseGraph: cmap");
nnbrs = graph->nnbrs;
peind = graph->peind;
recvind = graph->recvind;
recvptr = graph->recvptr;
/* Initialize the coarser graph */
cgraph = CreateGraph();
cgraph->nvtxs = cnvtxs;
cgraph->ncon = ncon;
cgraph->level = graph->level+1;
cgraph->finer = graph;
graph->coarser = cgraph;
/*************************************************************
* Obtain the vtxdist of the coarser graph
**************************************************************/
cvtxdist = cgraph->vtxdist = imalloc(npes+1, "Global_CreateCoarseGraph: cvtxdist");
cvtxdist[npes] = cnvtxs; /* Use last position in the cvtxdist as a temp buffer */
gkMPI_Allgather((void *)(cvtxdist+npes), 1, IDX_T, (void *)cvtxdist, 1,
IDX_T, ctrl->comm);
MAKECSR(i, npes, cvtxdist);
cgraph->gnvtxs = cvtxdist[npes];
#ifdef DEBUG_CONTRACT
PrintVector(ctrl, npes+1, 0, cvtxdist, "cvtxdist");
#endif
/*************************************************************
* Construct the cmap vector
**************************************************************/
cfirstvtx = cvtxdist[mype];
clastvtx = cvtxdist[mype+1];
/* Create the cmap of what you know so far locally. */
for (cnvtxs=0, i=0; i<nvtxs; i++) {
if (match[i] >= KEEP_BIT) {
k = match[i] - KEEP_BIT;
if (k>=firstvtx && k<firstvtx+i)
continue; /* Both (i,k) are local and i has been matched via the (k,i) side */
cmap[i] = cfirstvtx + cnvtxs++;
if (k != firstvtx+i && (k>=firstvtx && k<lastvtx)) { /* I'm matched locally */
cmap[k-firstvtx] = cmap[i];
match[k-firstvtx] += KEEP_BIT; /* Add the KEEP_BIT to simplify coding */
}
}
}
PASSERT(ctrl, cnvtxs == clastvtx-cfirstvtx);
CommInterfaceData(ctrl, graph, cmap, cmap+nvtxs);
/* Update the cmap of the locally stored vertices that will go away.
* The remote processor assigned cmap for them */
for (i=0; i<nvtxs; i++) {
if (match[i] < KEEP_BIT) { /* Only vertices that go away satisfy this*/
cmap[i] = cmap[nvtxs+BSearch(graph->nrecv, recvind, match[i])];
}
}
CommInterfaceData(ctrl, graph, cmap, cmap+nvtxs);
#ifndef NDEBUG
for (i=0; i<nvtxs+graph->nrecv; i++) {
if (cmap[i] == -1)
errexit("cmap[%"PRIDX"] == -1\n", i);
}
#endif
#ifdef DEBUG_CONTRACT
PrintVector(ctrl, nvtxs, firstvtx, cmap, "Cmap");
#endif
/*************************************************************
* Determine how many adjcency lists you need to send/receive.
**************************************************************/
/* first pass: determine sizes */
for (nsend=0, nrecv=0, i=0; i<nvtxs; i++) {
if (match[i] < KEEP_BIT) /* This is going away */
nsend++;
else {
k = match[i]-KEEP_BIT;
if (k<firstvtx || k>=lastvtx) /* This is comming from afar */
nrecv++;
}
}
scand = ikvwspacemalloc(ctrl, nsend);
rcand = graph->rcand = ikvmalloc(nrecv, "CreateCoarseGraph: rcand");
/* second pass: place them in the appropriate arrays */
nkeepsize = nsend = nrecv = 0;
for (i=0; i<nvtxs; i++) {
if (match[i] < KEEP_BIT) { /* This is going away */
scand[nsend].key = match[i];
scand[nsend].val = i;
nsend++;
}
else {
nkeepsize += (xadj[i+1]-xadj[i]);
k = match[i]-KEEP_BIT;
if (k<firstvtx || k>=lastvtx) { /* This is comming from afar */
rcand[nrecv].key = k;
rcand[nrecv].val = cmap[i] - cfirstvtx; /* Set it for use during the partition projection */
PASSERT(ctrl, rcand[nrecv].val>=0 && rcand[nrecv].val<cnvtxs);
nrecv++;
}
}
}
#ifdef DEBUG_CONTRACT
PrintPairs(ctrl, nsend, scand, "scand");
PrintPairs(ctrl, nrecv, rcand, "rcand");
#endif
/***************************************************************
* Determine how many lists and their sizes you will send and
* received for each of the neighboring PEs
****************************************************************/
rlens = graph->rlens = imalloc(nnbrs+1, "CreateCoarseGraph: graph->rlens");
slens = graph->slens = imalloc(nnbrs+1, "CreateCoarseGraph: graph->slens");
rsizes = iset(nnbrs, 0, iwspacemalloc(ctrl, nnbrs));
ssizes = iset(nnbrs, 0, iwspacemalloc(ctrl, nnbrs));
/* Take care the sending data first */
ikvsortii(nsend, scand);
slens[0] = 0;
for (k=i=0; i<nnbrs; i++) {
otherlastvtx = vtxdist[peind[i]+1];
for (; k<nsend && scand[k].key < otherlastvtx; k++)
ssizes[i] += (xadj[scand[k].val+1]-xadj[scand[k].val]);
slens[i+1] = k;
}
/* Take care the receiving data next. You cannot yet determine the rsizes[] */
ikvsortii(nrecv, rcand);
rlens[0] = 0;
for (k=i=0; i<nnbrs; i++) {
otherlastvtx = vtxdist[peind[i]+1];
for (; k<nrecv && rcand[k].key < otherlastvtx; k++);
rlens[i+1] = k;
}
#ifdef DEBUG_CONTRACT
PrintVector(ctrl, nnbrs+1, 0, slens, "slens");
PrintVector(ctrl, nnbrs+1, 0, rlens, "rlens");
#endif
/***************************************************************
* Exchange size information
****************************************************************/
/* Issue the receives first. */
for (i=0; i<nnbrs; i++) {
if (rlens[i+1]-rlens[i] > 0) /* Issue a receive only if you are getting something */
gkMPI_Irecv((void *)(rsizes+i), 1, IDX_T, peind[i], 1, ctrl->comm, ctrl->rreq+i);
}
/* Take care the sending data next */
for (i=0; i<nnbrs; i++) {
if (slens[i+1]-slens[i] > 0) /* Issue a send only if you are sending something */
gkMPI_Isend((void *)(ssizes+i), 1, IDX_T, peind[i], 1, ctrl->comm, ctrl->sreq+i);
}
/* OK, now get into the loop waiting for the operations to finish */
for (i=0; i<nnbrs; i++) {
if (rlens[i+1]-rlens[i] > 0)
gkMPI_Wait(ctrl->rreq+i, &ctrl->status);
}
for (i=0; i<nnbrs; i++) {
if (slens[i+1]-slens[i] > 0)
gkMPI_Wait(ctrl->sreq+i, &ctrl->status);
}
#ifdef DEBUG_CONTRACT
PrintVector(ctrl, nnbrs, 0, rsizes, "rsizes");
PrintVector(ctrl, nnbrs, 0, ssizes, "ssizes");
#endif
/*************************************************************
* Allocate memory for received/sent graphs and start sending
* and receiving data.
* rgraph and sgraph is a different data structure than CSR
* to facilitate single message exchange.
**************************************************************/
nrecvsize = isum(nnbrs, rsizes, 1);
nsendsize = isum(nnbrs, ssizes, 1);
rgraph = iwspacemalloc(ctrl, (4+ncon)*nrecv+2*nrecvsize);
WCOREPUSH; /* for freeing sgraph right away */
sgraph = iwspacemalloc(ctrl, (4+ncon)*nsend+2*nsendsize);
/* Deal with the received portion first */
for (l=i=0; i<nnbrs; i++) {
/* Issue a receive only if you are getting something */
if (rlens[i+1]-rlens[i] > 0) {
gkMPI_Irecv((void *)(rgraph+l), (4+ncon)*(rlens[i+1]-rlens[i])+2*rsizes[i],
IDX_T, peind[i], 1, ctrl->comm, ctrl->rreq+i);
l += (4+ncon)*(rlens[i+1]-rlens[i])+2*rsizes[i];
}
}
/* Deal with the sent portion now */
for (ll=l=i=0; i<nnbrs; i++) {
if (slens[i+1]-slens[i] > 0) { /* Issue a send only if you are sending something */
for (k=slens[i]; k<slens[i+1]; k++) {
ii = scand[k].val;
sgraph[ll++] = firstvtx+ii;
sgraph[ll++] = xadj[ii+1]-xadj[ii];
for (h=0; h<ncon; h++)
sgraph[ll++] = vwgt[ii*ncon+h];
sgraph[ll++] = (ctrl->partType == STATIC_PARTITION || ctrl->partType == ORDER_PARTITION
? -1 : vsize[ii]);
sgraph[ll++] = (ctrl->partType == STATIC_PARTITION || ctrl->partType == ORDER_PARTITION
? -1 : home[ii]);
for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) {
sgraph[ll++] = cmap[adjncy[jj]];
sgraph[ll++] = adjwgt[jj];
}
}
PASSERT(ctrl, ll-l == (4+ncon)*(slens[i+1]-slens[i])+2*ssizes[i]);
/*myprintf(ctrl, "Sending to pe:%"PRIDX", %"PRIDX" lists of size %"PRIDX"\n", peind[i], slens[i+1]-slens[i], ssizes[i]); */
gkMPI_Isend((void *)(sgraph+l), ll-l, IDX_T, peind[i], 1, ctrl->comm, ctrl->sreq+i);
l = ll;
}
}
/* OK, now get into the loop waiting for the operations to finish */
for (i=0; i<nnbrs; i++) {
if (rlens[i+1]-rlens[i] > 0)
gkMPI_Wait(ctrl->rreq+i, &ctrl->status);
}
for (i=0; i<nnbrs; i++) {
if (slens[i+1]-slens[i] > 0)
gkMPI_Wait(ctrl->sreq+i, &ctrl->status);
}
#ifdef DEBUG_CONTRACT
rprintf(ctrl, "Graphs were sent!\n");
PrintTransferedGraphs(ctrl, nnbrs, peind, slens, rlens, sgraph, rgraph);
#endif
WCOREPOP; /* free sgraph */
/*************************************************************
* Setup the mapping from indices returned by BSearch to
* those that are actually stored
**************************************************************/
perm = iset(graph->nrecv, -1, iwspacemalloc(ctrl, graph->nrecv));
for (j=i=0; i<nrecv; i++) {
perm[BSearch(graph->nrecv, recvind, rgraph[j])] = j+1;
j += (4+ncon)+2*rgraph[j+1];
}
/*************************************************************
* Finally, create the coarser graph
**************************************************************/
/* Allocate memory for the coarser graph, and fire up coarsening */
cxadj = cgraph->xadj = imalloc(cnvtxs+1, "CreateCoarserGraph: cxadj");
cvwgt = cgraph->vwgt = imalloc(cnvtxs*ncon, "CreateCoarserGraph: cvwgt");
cnvwgt = cgraph->nvwgt = rmalloc(cnvtxs*ncon, "CreateCoarserGraph: cnvwgt");
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION) {
cvsize = cgraph->vsize = imalloc(cnvtxs, "CreateCoarserGraph: cvsize");
chome = cgraph->home = imalloc(cnvtxs, "CreateCoarserGraph: chome");
}
if (where != NULL)
cwhere = cgraph->where = imalloc(cnvtxs, "CreateCoarserGraph: cwhere");
/* these are just upper bound estimates for now */
cadjncy = iwspacemalloc(ctrl, nkeepsize+nrecvsize);
cadjwgt = iwspacemalloc(ctrl, nkeepsize+nrecvsize);
iset(LHTSIZE, -1, htable);
cxadj[0] = cnvtxs = cnedges = 0;
for (i=0; i<nvtxs; i++) {
if (match[i] >= KEEP_BIT) {
v = firstvtx+i;
u = match[i]-KEEP_BIT;
if (u>=firstvtx && u<lastvtx && v > u)
continue; /* I have already collapsed it as (u,v) */
/* Collapse the v vertex first, which you know is local */
for (h=0; h<ncon; h++)
cvwgt[cnvtxs*ncon+h] = vwgt[i*ncon+h];
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION) {
cvsize[cnvtxs] = vsize[i];
chome[cnvtxs] = home[i];
}
if (where != NULL)
cwhere[cnvtxs] = where[i];
nedges = 0;
/* Collapse the v (i) vertex first */
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = cmap[adjncy[j]];
if (k < 0)
printf("k=%d\n", (int)k);
if (k != cfirstvtx+cnvtxs) { /* If this is not an internal edge */
l = k&MASK;
if (htable[l] == -1) { /* Seeing this for first time */
htable[l] = k;
htableidx[l] = cnedges+nedges;
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges++] = adjwgt[j];
}
else if (htable[l] == k) {
cadjwgt[htableidx[l]] += adjwgt[j];
}
else { /* Now you have to go and do a search. Expensive case */
for (l=0; l<nedges; l++) {
if (cadjncy[cnedges+l] == k)
break;
}
if (l < nedges) {
cadjwgt[cnedges+l] += adjwgt[j];
}
else {
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges++] = adjwgt[j];
}
}
}
}
/* Collapse the u vertex next */
if (v != u) {
if (u>=firstvtx && u<lastvtx) { /* Local vertex */
u -= firstvtx;
for (h=0; h<ncon; h++)
cvwgt[cnvtxs*ncon+h] += vwgt[u*ncon+h];
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION)
cvsize[cnvtxs] += vsize[u];
for (j=xadj[u]; j<xadj[u+1]; j++) {
k = cmap[adjncy[j]];
if (k != cfirstvtx+cnvtxs) { /* If this is not an internal edge */
l = k&MASK;
if (htable[l] == -1) { /* Seeing this for first time */
htable[l] = k;
htableidx[l] = cnedges+nedges;
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges] = adjwgt[j];
nedges++;
}
else if (htable[l] == k) {
cadjwgt[htableidx[l]] += adjwgt[j];
}
else { /* Now you have to go and do a search. Expensive case */
for (l=0; l<nedges; l++) {
if (cadjncy[cnedges+l] == k)
break;
}
if (l < nedges) {
cadjwgt[cnedges+l] += adjwgt[j];
}
else {
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges] = adjwgt[j];
nedges++;
}
}
}
}
}
else { /* Remote vertex */
u = perm[BSearch(graph->nrecv, recvind, u)];
for (h=0; h<ncon; h++)
/* Remember that the +1 stores the vertex weight */
cvwgt[cnvtxs*ncon+h] += rgraph[(u+1)+h];
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION) {
cvsize[cnvtxs] += rgraph[u+1+ncon];
chome[cnvtxs] = rgraph[u+2+ncon];
}
for (j=0; j<rgraph[u]; j++) {
k = rgraph[u+3+ncon+2*j];
if (k != cfirstvtx+cnvtxs) { /* If this is not an internal edge */
l = k&MASK;
if (htable[l] == -1) { /* Seeing this for first time */
htable[l] = k;
htableidx[l] = cnedges+nedges;
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges] = rgraph[u+3+ncon+2*j+1];
nedges++;
}
else if (htable[l] == k) {
cadjwgt[htableidx[l]] += rgraph[u+3+ncon+2*j+1];
}
else { /* Now you have to go and do a search. Expensive case */
for (l=0; l<nedges; l++) {
if (cadjncy[cnedges+l] == k)
break;
}
if (l < nedges) {
cadjwgt[cnedges+l] += rgraph[u+3+ncon+2*j+1];
}
else {
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges] = rgraph[u+3+ncon+2*j+1];
nedges++;
}
}
}
}
}
}
cnedges += nedges;
for (j=cxadj[cnvtxs]; j<cnedges; j++)
htable[cadjncy[j]&MASK] = -1; /* reset the htable */
cxadj[++cnvtxs] = cnedges;
}
}
cgraph->nedges = cnedges;
/* ADD: In order to keep from having to change this too much */
/* ADD: I kept vwgt array and recomputed nvwgt for each coarser graph */
for (j=0; j<cnvtxs; j++) {
for (h=0; h<ncon; h++)
cgraph->nvwgt[j*ncon+h] = ctrl->invtvwgts[h]*cvwgt[j*ncon+h];
}
cgraph->adjncy = imalloc(cnedges, "CreateCoarserGraph: cadjncy");
cgraph->adjwgt = imalloc(cnedges, "CreateCoarserGraph: cadjwgt");
icopy(cnedges, cadjncy, cgraph->adjncy);
icopy(cnedges, cadjwgt, cgraph->adjwgt);
WCOREPOP;
/* Note that graph->where works fine even if it is NULL */
gk_free((void **)&graph->where, LTERM);
}
void GrowBisection(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts,
idx_t niparts)
{
idx_t i, j, k, nvtxs, drain, nleft, first, last,
pwgts[2], oneminpwgt, onemaxpwgt,
from, me, bestcut=0, icut, mincut, inbfs;
idx_t *xadj, *vwgt, *adjncy, *where;
idx_t *queue, *touched, *gain, *bestwhere;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
// adjwgt = graph->adjwgt;
Allocate2WayPartitionMemory(ctrl, graph);
where = graph->where;
bestwhere = iwspacemalloc(ctrl, nvtxs);
queue = iwspacemalloc(ctrl, nvtxs);
touched = iwspacemalloc(ctrl, nvtxs);
onemaxpwgt = ctrl->ubfactors[0]*graph->tvwgt[0]*ntpwgts[1];
oneminpwgt = (1.0/ctrl->ubfactors[0])*graph->tvwgt[0]*ntpwgts[1];
for (inbfs=0; inbfs<niparts; inbfs++) {
iset(nvtxs, 1, where);
iset(nvtxs, 0, touched);
pwgts[1] = graph->tvwgt[0];
pwgts[0] = 0;
queue[0] = irandInRange(nvtxs);
touched[queue[0]] = 1;
first = 0;
last = 1;
nleft = nvtxs-1;
drain = 0;
/* Start the BFS from queue to get a partition */
for (;;) {
if (first == last) { /* Empty. Disconnected graph! */
if (nleft == 0 || drain)
break;
k = irandInRange(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[0] > 0 && pwgts[1]-vwgt[i] < oneminpwgt) {
drain = 1;
continue;
}
where[i] = 0;
INC_DEC(pwgts[0], pwgts[1], vwgt[i]);
if (pwgts[1] <= onemaxpwgt)
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--;
}
}
}
/* Check to see if we hit any bad limiting cases */
if (pwgts[1] == 0)
where[irandInRange(nvtxs)] = 1;
if (pwgts[0] == 0)
where[irandInRange(nvtxs)] = 0;
/*************************************************************
* Do some partition refinement
**************************************************************/
Compute2WayPartitionParams(ctrl, graph);
/*
printf("IPART: %3"PRIDX" [%5"PRIDX" %5"PRIDX"] [%5"PRIDX" %5"PRIDX"] %5"PRIDX"\n",
graph->nvtxs, pwgts[0], pwgts[1], graph->pwgts[0], graph->pwgts[1], graph->mincut);
*/
Balance2Way(ctrl, graph, ntpwgts);
/*
printf("BPART: [%5"PRIDX" %5"PRIDX"] %5"PRIDX"\n", graph->pwgts[0],
graph->pwgts[1], graph->mincut);
*/
FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
/*
printf("RPART: [%5"PRIDX" %5"PRIDX"] %5"PRIDX"\n", graph->pwgts[0],
graph->pwgts[1], graph->mincut);
*/
if (inbfs == 0 || bestcut > graph->mincut) {
bestcut = graph->mincut;
icopy(nvtxs, where, bestwhere);
if (bestcut == 0)
break;
}
}
graph->mincut = bestcut;
icopy(nvtxs, bestwhere, where);
WCOREPOP;
}
void RandomBisection(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts,
idx_t niparts)
{
idx_t i, ii, j, k, nvtxs, pwgts[2], zeromaxpwgt, from, me,
bestcut=0, icut, mincut, inbfs;
idx_t *vwgt, *where;
idx_t *perm, *bestwhere;
WCOREPUSH;
nvtxs = graph->nvtxs;
// xadj = graph->xadj;
vwgt = graph->vwgt;
// adjncy = graph->adjncy;
// adjwgt = graph->adjwgt;
Allocate2WayPartitionMemory(ctrl, graph);
where = graph->where;
bestwhere = iwspacemalloc(ctrl, nvtxs);
perm = iwspacemalloc(ctrl, nvtxs);
zeromaxpwgt = ctrl->ubfactors[0]*graph->tvwgt[0]*ntpwgts[0];
for (inbfs=0; inbfs<niparts; inbfs++) {
iset(nvtxs, 1, where);
if (inbfs > 0) {
irandArrayPermute(nvtxs, perm, nvtxs/2, 1);
pwgts[1] = graph->tvwgt[0];
pwgts[0] = 0;
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (pwgts[0]+vwgt[i] < zeromaxpwgt) {
where[i] = 0;
pwgts[0] += vwgt[i];
pwgts[1] -= vwgt[i];
if (pwgts[0] > zeromaxpwgt)
break;
}
}
}
/* Do some partition refinement */
Compute2WayPartitionParams(ctrl, graph);
/* printf("IPART: %3"PRIDX" [%5"PRIDX" %5"PRIDX"] [%5"PRIDX" %5"PRIDX"] %5"PRIDX"\n", graph->nvtxs, pwgts[0], pwgts[1], graph->pwgts[0], graph->pwgts[1], graph->mincut); */
Balance2Way(ctrl, graph, ntpwgts);
/* printf("BPART: [%5"PRIDX" %5"PRIDX"] %5"PRIDX"\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */
FM_2WayRefine(ctrl, graph, ntpwgts, 4);
/* printf("RPART: [%5"PRIDX" %5"PRIDX"] %5"PRIDX"\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */
if (inbfs==0 || bestcut > graph->mincut) {
bestcut = graph->mincut;
icopy(nvtxs, where, bestwhere);
if (bestcut == 0)
break;
}
}
graph->mincut = bestcut;
icopy(nvtxs, bestwhere, where);
WCOREPOP;
}
void SplitGraphOrder(ctrl_t *ctrl, graph_t *graph, graph_t **r_lgraph,
graph_t **r_rgraph)
{
idx_t i, ii, j, k, l, istart, iend, mypart, nvtxs, snvtxs[3], snedges[3];
idx_t *xadj, *vwgt, *adjncy, *adjwgt, *label, *where, *bndptr, *bndind;
idx_t *sxadj[2], *svwgt[2], *sadjncy[2], *sadjwgt[2], *slabel[2];
idx_t *rename;
idx_t *auxadjncy;
graph_t *lgraph, *rgraph;
WCOREPUSH;
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startcputimer(ctrl->SplitTmr));
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
label = graph->label;
where = graph->where;
bndptr = graph->bndptr;
bndind = graph->bndind;
ASSERT(bndptr != NULL);
rename = iwspacemalloc(ctrl, nvtxs);
snvtxs[0] = snvtxs[1] = snvtxs[2] = snedges[0] = snedges[1] = snedges[2] = 0;
for (i=0; i<nvtxs; i++) {
k = where[i];
rename[i] = snvtxs[k]++;
snedges[k] += xadj[i+1]-xadj[i];
}
lgraph = SetupSplitGraph(graph, snvtxs[0], snedges[0]);
sxadj[0] = lgraph->xadj;
svwgt[0] = lgraph->vwgt;
sadjncy[0] = lgraph->adjncy;
sadjwgt[0] = lgraph->adjwgt;
slabel[0] = lgraph->label;
rgraph = SetupSplitGraph(graph, snvtxs[1], snedges[1]);
sxadj[1] = rgraph->xadj;
svwgt[1] = rgraph->vwgt;
sadjncy[1] = rgraph->adjncy;
sadjwgt[1] = rgraph->adjwgt;
slabel[1] = rgraph->label;
/* Go and use bndptr to also mark the boundary nodes in the two partitions */
for (ii=0; ii<graph->nbnd; ii++) {
i = bndind[ii];
for (j=xadj[i]; j<xadj[i+1]; j++)
bndptr[adjncy[j]] = 1;
}
snvtxs[0] = snvtxs[1] = snedges[0] = snedges[1] = 0;
sxadj[0][0] = sxadj[1][0] = 0;
for (i=0; i<nvtxs; i++) {
if ((mypart = where[i]) == 2)
continue;
istart = xadj[i];
iend = xadj[i+1];
if (bndptr[i] == -1) { /* This is an interior vertex */
auxadjncy = sadjncy[mypart] + snedges[mypart] - istart;
for(j=istart; j<iend; j++)
auxadjncy[j] = adjncy[j];
snedges[mypart] += iend-istart;
}
else {
auxadjncy = sadjncy[mypart];
l = snedges[mypart];
for (j=istart; j<iend; j++) {
k = adjncy[j];
if (where[k] == mypart)
auxadjncy[l++] = k;
}
snedges[mypart] = l;
}
svwgt[mypart][snvtxs[mypart]] = vwgt[i];
slabel[mypart][snvtxs[mypart]] = label[i];
sxadj[mypart][++snvtxs[mypart]] = snedges[mypart];
}
for (mypart=0; mypart<2; mypart++) {
iend = snedges[mypart];
iset(iend, 1, sadjwgt[mypart]);
auxadjncy = sadjncy[mypart];
for (i=0; i<iend; i++)
auxadjncy[i] = rename[auxadjncy[i]];
}
lgraph->nvtxs = snvtxs[0];
lgraph->nedges = snedges[0];
rgraph->nvtxs = snvtxs[1];
rgraph->nedges = snedges[1];
SetupGraph_tvwgt(lgraph);
SetupGraph_tvwgt(rgraph);
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopcputimer(ctrl->SplitTmr));
*r_lgraph = lgraph;
*r_rgraph = rgraph;
WCOREPOP;
}
void Match_Local(ctrl_t *ctrl, graph_t *graph)
{
idx_t h, i, ii, j, k;
idx_t nvtxs, ncon, cnvtxs, firstvtx, maxi, maxidx, edge;
idx_t *xadj, *adjncy, *adjwgt, *vtxdist, *home, *myhome;
idx_t *perm, *match;
real_t maxnvwgt, *nvwgt;
WCOREPUSH;
maxnvwgt = 0.75/((real_t)ctrl->CoarsenTo);
graph->match_type = PARMETIS_MTYPE_LOCAL;
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->comm));
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
nvwgt = graph->nvwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
home = graph->home;
vtxdist = graph->vtxdist;
firstvtx = vtxdist[ctrl->mype];
match = graph->match = imalloc(nvtxs+graph->nrecv, "HEM_Match: match");
/* wspacemalloc'ed arrays */
myhome = iset(nvtxs+graph->nrecv, UNMATCHED, iwspacemalloc(ctrl, nvtxs+graph->nrecv));
perm = iwspacemalloc(ctrl, nvtxs);
/* if coasening for adaptive/repartition, exchange home information */
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION) {
icopy(nvtxs, home, myhome);
CommInterfaceData(ctrl, graph, myhome, myhome+nvtxs);
}
/*************************************************************
* Go now and find a local matching
*************************************************************/
iset(nvtxs, UNMATCHED, match);
iset(graph->nrecv, 0, match+nvtxs); /* Easy way to handle remote vertices */
FastRandomPermute(nvtxs, perm, 1);
for (cnvtxs=0, ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) {
maxidx = maxi = -1;
/* Find a heavy-edge matching, if the weight of the vertex is OK */
for (h=0; h<ncon; h++)
if (nvwgt[i*ncon+h] > maxnvwgt)
break;
if (h == ncon && ii<nvtxs) {
for (j=xadj[i]; j<xadj[i+1]; j++) {
edge = adjncy[j];
/* match only with local vertices */
if (myhome[edge] != myhome[i] || edge >= nvtxs)
continue;
for (h=0; h<ncon; h++)
if (nvwgt[edge*ncon+h] > maxnvwgt)
break;
if (h == ncon) {
if (match[edge] == UNMATCHED &&
(maxi == -1 ||
adjwgt[maxi] < adjwgt[j] ||
(adjwgt[maxi] == adjwgt[j] &&
BetterVBalance(ncon,nvwgt+i*ncon,nvwgt+maxidx*ncon,nvwgt+edge*ncon) >= 0))) {
maxi = j;
maxidx = edge;
}
}
}
}
if (maxi != -1) {
k = adjncy[maxi];
match[i] = firstvtx+k + (i <= k ? KEEP_BIT : 0);
match[k] = firstvtx+i + (i > k ? KEEP_BIT : 0);
}
else {
match[i] = firstvtx+i + KEEP_BIT;
}
cnvtxs++;
}
}
CommInterfaceData(ctrl, graph, match, match+nvtxs);
#ifdef DEBUG_MATCH
PrintVector2(ctrl, nvtxs, firstvtx, match, "Match1");
#endif
if (ctrl->dbglvl&DBG_MATCHINFO) {
PrintVector2(ctrl, nvtxs, firstvtx, match, "Match");
myprintf(ctrl, "Cnvtxs: %"PRIDX"\n", cnvtxs);
rprintf(ctrl, "Done with matching...\n");
}
WCOREPOP;
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->comm));
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ContractTmr));
CreateCoarseGraph_Local(ctrl, graph, cnvtxs);
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ContractTmr));
}
void ProjectKWayPartition(ctrl_t *ctrl, graph_t *graph)
{
idx_t i, j, k, nvtxs, nbnd, nparts, me, other, istart, iend, tid, ted;
idx_t *xadj, *adjncy, *adjwgt;
idx_t *cmap, *where, *bndptr, *bndind, *cwhere, *htable;
graph_t *cgraph;
WCOREPUSH;
nparts = ctrl->nparts;
cgraph = graph->coarser;
cwhere = cgraph->where;
nvtxs = graph->nvtxs;
cmap = graph->cmap;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
AllocateKWayPartitionMemory(ctrl, graph);
where = graph->where;
bndind = graph->bndind;
bndptr = iset(nvtxs, -1, graph->bndptr);
htable = iset(nparts, -1, iwspacemalloc(ctrl, nparts));
/* Compute the required info for refinement */
switch (ctrl->objtype) {
case METIS_OBJTYPE_CUT:
ASSERT(CheckBnd2(cgraph));
{
ckrinfo_t *myrinfo;
cnbr_t *mynbrs;
/* go through and project partition and compute id/ed for the nodes */
for (i=0; i<nvtxs; i++) {
k = cmap[i];
where[i] = cwhere[k];
cmap[i] = cgraph->ckrinfo[k].ed; /* For optimization */
}
memset(graph->ckrinfo, 0, sizeof(ckrinfo_t)*nvtxs);
cnbrpoolReset(ctrl);
for (nbnd=0, i=0; i<nvtxs; i++) {
istart = xadj[i];
iend = xadj[i+1];
myrinfo = graph->ckrinfo+i;
if (cmap[i] == 0) { /* Interior node. Note that cmap[i] = crinfo[cmap[i]].ed */
for (tid=0, j=istart; j<iend; j++)
tid += adjwgt[j];
myrinfo->id = tid;
myrinfo->inbr = -1;
}
else { /* Potentially an interface node */
myrinfo->inbr = cnbrpoolGetNext(ctrl, iend-istart+1);
mynbrs = ctrl->cnbrpool + myrinfo->inbr;
me = where[i];
for (tid=0, ted=0, j=istart; j<iend; j++) {
other = where[adjncy[j]];
if (me == other) {
tid += adjwgt[j];
}
else {
ted += adjwgt[j];
if ((k = htable[other]) == -1) {
htable[other] = myrinfo->nnbrs;
mynbrs[myrinfo->nnbrs].pid = other;
mynbrs[myrinfo->nnbrs++].ed = adjwgt[j];
}
else {
mynbrs[k].ed += adjwgt[j];
}
}
}
myrinfo->id = tid;
myrinfo->ed = ted;
/* Remove space for edegrees if it was interior */
if (ted == 0) {
ctrl->nbrpoolcpos -= iend-istart+1;
myrinfo->inbr = -1;
}
else {
if (ted-tid >= 0)
BNDInsert(nbnd, bndind, bndptr, i);
for (j=0; j<myrinfo->nnbrs; j++)
htable[mynbrs[j].pid] = -1;
}
}
}
graph->nbnd = nbnd;
}
ASSERT(CheckBnd2(graph));
break;
case METIS_OBJTYPE_VOL:
{
vkrinfo_t *myrinfo;
vnbr_t *mynbrs;
ASSERT(cgraph->minvol == ComputeVolume(cgraph, cgraph->where));
/* go through and project partition and compute id/ed for the nodes */
for (i=0; i<nvtxs; i++) {
k = cmap[i];
where[i] = cwhere[k];
cmap[i] = cgraph->vkrinfo[k].ned; /* For optimization */
}
memset(graph->vkrinfo, 0, sizeof(vkrinfo_t)*nvtxs);
vnbrpoolReset(ctrl);
for (i=0; i<nvtxs; i++) {
istart = xadj[i];
iend = xadj[i+1];
myrinfo = graph->vkrinfo+i;
if (cmap[i] == 0) { /* Note that cmap[i] = crinfo[cmap[i]].ed */
myrinfo->nid = iend-istart;
myrinfo->inbr = -1;
}
else { /* Potentially an interface node */
myrinfo->inbr = vnbrpoolGetNext(ctrl, iend-istart+1);
mynbrs = ctrl->vnbrpool + myrinfo->inbr;
me = where[i];
for (tid=0, ted=0, j=istart; j<iend; j++) {
other = where[adjncy[j]];
if (me == other) {
tid++;
}
else {
ted++;
if ((k = htable[other]) == -1) {
htable[other] = myrinfo->nnbrs;
mynbrs[myrinfo->nnbrs].gv = 0;
mynbrs[myrinfo->nnbrs].pid = other;
mynbrs[myrinfo->nnbrs++].ned = 1;
}
else {
mynbrs[k].ned++;
}
}
}
myrinfo->nid = tid;
myrinfo->ned = ted;
/* Remove space for edegrees if it was interior */
if (ted == 0) {
ctrl->nbrpoolcpos -= iend-istart+1;
myrinfo->inbr = -1;
}
else {
for (j=0; j<myrinfo->nnbrs; j++)
htable[mynbrs[j].pid] = -1;
}
}
}
ComputeKWayVolGains(ctrl, graph);
ASSERT(graph->minvol == ComputeVolume(graph, graph->where));
}
break;
default:
gk_errexit(SIGERR, "Unknown objtype of %d\n", ctrl->objtype);
}
graph->mincut = cgraph->mincut;
icopy(nparts*graph->ncon, cgraph->pwgts, graph->pwgts);
FreeGraph(&graph->coarser);
graph->coarser = NULL;
WCOREPOP;
}
void FM_2WayCutRefine(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts, idx_t niter)
{
idx_t i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, limit, tmp;
idx_t *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts;
idx_t *moved, *swaps, *perm;
rpq_t *queues[2];
idx_t higain, mincut, mindiff, origdiff, initcut, newcut, mincutorder, avgvwgt;
idx_t tpwgts[2];
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
pwgts = graph->pwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
moved = iwspacemalloc(ctrl, nvtxs);
swaps = iwspacemalloc(ctrl, nvtxs);
perm = iwspacemalloc(ctrl, nvtxs);
tpwgts[0] = graph->tvwgt[0]*ntpwgts[0];
tpwgts[1] = graph->tvwgt[0]-tpwgts[0];
limit = gk_min(gk_max(0.01*nvtxs, 15), 100);
avgvwgt = gk_min((pwgts[0]+pwgts[1])/20, 2*(pwgts[0]+pwgts[1])/nvtxs);
queues[0] = rpqCreate(nvtxs);
queues[1] = rpqCreate(nvtxs);
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
Print2WayRefineStats(ctrl, graph, ntpwgts, 0, -2));
origdiff = iabs(tpwgts[0]-pwgts[0]);
iset(nvtxs, -1, moved);
for (pass=0; pass<niter; pass++) { /* Do a number of passes */
rpqReset(queues[0]);
rpqReset(queues[1]);
mincutorder = -1;
newcut = mincut = initcut = graph->mincut;
mindiff = iabs(tpwgts[0]-pwgts[0]);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert boundary nodes in the priority queues */
nbnd = graph->nbnd;
irandArrayPermute(nbnd, perm, nbnd, 1);
for (ii=0; ii<nbnd; ii++) {
i = perm[ii];
ASSERT(ed[bndind[i]] > 0 || id[bndind[i]] == 0);
ASSERT(bndptr[bndind[i]] != -1);
rpqInsert(queues[where[bndind[i]]], bndind[i], ed[bndind[i]]-id[bndind[i]]);
}
for (nswaps=0; nswaps<nvtxs; nswaps++) {
from = (tpwgts[0]-pwgts[0] < tpwgts[1]-pwgts[1] ? 0 : 1);
to = (from+1)%2;
if ((higain = rpqGetTop(queues[from])) == -1)
break;
ASSERT(bndptr[higain] != -1);
newcut -= (ed[higain]-id[higain]);
INC_DEC(pwgts[to], pwgts[from], vwgt[higain]);
if ((newcut < mincut && iabs(tpwgts[0]-pwgts[0]) <= origdiff+avgvwgt) ||
(newcut == mincut && iabs(tpwgts[0]-pwgts[0]) < mindiff)) {
mincut = newcut;
mindiff = iabs(tpwgts[0]-pwgts[0]);
mincutorder = nswaps;
}
else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
newcut += (ed[higain]-id[higain]);
INC_DEC(pwgts[from], pwgts[to], vwgt[higain]);
break;
}
where[higain] = to;
moved[higain] = nswaps;
swaps[nswaps] = higain;
IFSET(ctrl->dbglvl, METIS_DBG_MOVEINFO,
printf("Moved %6"PRIDX" from %"PRIDX". [%3"PRIDX" %3"PRIDX"] %5"PRIDX" [%4"PRIDX" %4"PRIDX"]\n", higain, from, ed[higain]-id[higain], vwgt[higain], newcut, pwgts[0], pwgts[1]));
/**************************************************************
* Update the id[i]/ed[i] values of the affected nodes
***************************************************************/
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
/* Update its boundary information and queue position */
if (bndptr[k] != -1) { /* If k was a boundary vertex */
if (ed[k] == 0) { /* Not a boundary vertex any more */
BNDDelete(nbnd, bndind, bndptr, k);
if (moved[k] == -1) /* Remove it if in the queues */
rpqDelete(queues[where[k]], k);
}
else { /* If it has not been moved, update its position in the queue */
if (moved[k] == -1)
rpqUpdate(queues[where[k]], k, ed[k]-id[k]);
}
}
else {
if (ed[k] > 0) { /* It will now become a boundary vertex */
BNDInsert(nbnd, bndind, bndptr, k);
if (moved[k] == -1)
rpqInsert(queues[where[k]], k, ed[k]-id[k]);
}
}
}
}
/****************************************************************
* Roll back computations
*****************************************************************/
for (i=0; i<nswaps; i++)
moved[swaps[i]] = -1; /* reset moved array */
for (nswaps--; nswaps>mincutorder; nswaps--) {
higain = swaps[nswaps];
to = where[higain] = (where[higain]+1)%2;
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
else if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
INC_DEC(pwgts[to], pwgts[(to+1)%2], vwgt[higain]);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
if (bndptr[k] != -1 && ed[k] == 0)
BNDDelete(nbnd, bndind, bndptr, k);
if (bndptr[k] == -1 && ed[k] > 0)
BNDInsert(nbnd, bndind, bndptr, k);
}
}
graph->mincut = mincut;
graph->nbnd = nbnd;
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
Print2WayRefineStats(ctrl, graph, ntpwgts, 0, mincutorder));
if (mincutorder <= 0 || mincut == initcut)
break;
}
rpqDestroy(queues[0]);
rpqDestroy(queues[1]);
WCOREPOP;
}
void CreateCoarseGraph_Local(ctrl_t *ctrl, graph_t *graph, idx_t cnvtxs)
{
idx_t h, i, j, k, l;
idx_t nvtxs, ncon, nedges, firstvtx, cfirstvtx;
idx_t npes=ctrl->npes, mype=ctrl->mype;
idx_t cnedges, v, u;
idx_t *xadj, *vwgt, *vsize, *adjncy, *adjwgt, *vtxdist, *where, *home;
idx_t *match, *cmap;
idx_t *cxadj, *cvwgt, *cvsize = NULL, *cadjncy, *cadjwgt, *cvtxdist,
*chome = NULL, *cwhere = NULL;
real_t *cnvwgt;
graph_t *cgraph;
idx_t htable[LHTSIZE], htableidx[LHTSIZE];
WCOREPUSH;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
vwgt = graph->vwgt;
home = graph->home;
vsize = graph->vsize;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
match = graph->match;
vtxdist = graph->vtxdist;
firstvtx = vtxdist[mype];
cmap = graph->cmap = ismalloc(nvtxs+graph->nrecv, -1, "CreateCoarseGraph: cmap");
/* Initialize the coarser graph */
cgraph = CreateGraph();
cgraph->nvtxs = cnvtxs;
cgraph->level = graph->level+1;
cgraph->ncon = ncon;
cgraph->finer = graph;
graph->coarser = cgraph;
/*************************************************************
* Obtain the vtxdist of the coarser graph
**************************************************************/
cvtxdist = cgraph->vtxdist = imalloc(npes+1, "CreateCoarseGraph: cvtxdist");
cvtxdist[npes] = cnvtxs; /* Use last position in the cvtxdist as a temp buffer */
gkMPI_Allgather((void *)(cvtxdist+npes), 1, IDX_T, (void *)cvtxdist, 1, IDX_T, ctrl->comm);
MAKECSR(i, npes, cvtxdist);
cgraph->gnvtxs = cvtxdist[npes];
#ifdef DEBUG_CONTRACT
PrintVector(ctrl, npes+1, 0, cvtxdist, "cvtxdist");
#endif
/*************************************************************
* Construct the cmap vector
**************************************************************/
cfirstvtx = cvtxdist[mype];
/* Create the cmap of what you know so far locally */
cnvtxs = 0;
for (i=0; i<nvtxs; i++) {
if (match[i] >= KEEP_BIT) {
k = match[i] - KEEP_BIT;
if (k<firstvtx+i)
continue; /* i has been matched via the (k,i) side */
cmap[i] = cfirstvtx + cnvtxs++;
if (k != firstvtx+i) {
cmap[k-firstvtx] = cmap[i];
match[k-firstvtx] += KEEP_BIT; /* Add the KEEP_BIT to simplify coding */
}
}
}
CommInterfaceData(ctrl, graph, cmap, cmap+nvtxs);
#ifdef DEBUG_CONTRACT
PrintVector(ctrl, nvtxs, firstvtx, cmap, "Cmap");
#endif
/*************************************************************
* Finally, create the coarser graph
**************************************************************/
/* Allocate memory for the coarser graph, and fire up coarsening */
cxadj = cgraph->xadj = imalloc(cnvtxs+1, "CreateCoarserGraph: cxadj");
cvwgt = cgraph->vwgt = imalloc(cnvtxs*ncon, "CreateCoarserGraph: cvwgt");
cnvwgt = cgraph->nvwgt = rmalloc(cnvtxs*ncon, "CreateCoarserGraph: cnvwgt");
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION)
chome = cgraph->home = imalloc(cnvtxs, "CreateCoarserGraph: chome");
if (vsize != NULL)
cvsize = cgraph->vsize = imalloc(cnvtxs, "CreateCoarserGraph: cvsize");
if (where != NULL)
cwhere = cgraph->where = imalloc(cnvtxs, "CreateCoarserGraph: cwhere");
cadjncy = iwspacemalloc(ctrl, graph->nedges);
cadjwgt = iwspacemalloc(ctrl, graph->nedges);
iset(LHTSIZE, -1, htable);
cxadj[0] = cnvtxs = cnedges = 0;
for (i=0; i<nvtxs; i++) {
v = firstvtx+i;
u = match[i]-KEEP_BIT;
if (v > u)
continue; /* I have already collapsed it as (u,v) */
/* Collapse the v vertex first, which you know that is local */
for (h=0; h<ncon; h++)
cvwgt[cnvtxs*ncon+h] = vwgt[i*ncon+h];
if (ctrl->partType == ADAPTIVE_PARTITION || ctrl->partType == REFINE_PARTITION)
chome[cnvtxs] = home[i];
if (vsize != NULL)
cvsize[cnvtxs] = vsize[i];
if (where != NULL)
cwhere[cnvtxs] = where[i];
nedges = 0;
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = cmap[adjncy[j]];
if (k != cfirstvtx+cnvtxs) { /* If this is not an internal edge */
l = k&MASK;
if (htable[l] == -1) { /* Seeing this for first time */
htable[l] = k;
htableidx[l] = cnedges+nedges;
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges++] = adjwgt[j];
}
else if (htable[l] == k) {
cadjwgt[htableidx[l]] += adjwgt[j];
}
else { /* Now you have to go and do a search. Expensive case */
for (l=0; l<nedges; l++) {
if (cadjncy[cnedges+l] == k)
break;
}
if (l < nedges) {
cadjwgt[cnedges+l] += adjwgt[j];
}
else {
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges++] = adjwgt[j];
}
}
}
}
/* Collapse the u vertex next */
if (v != u) {
u -= firstvtx;
for (h=0; h<ncon; h++)
cvwgt[cnvtxs*ncon+h] += vwgt[u*ncon+h];
if (vsize != NULL)
cvsize[cnvtxs] += vsize[u];
if (where != NULL && cwhere[cnvtxs] != where[u])
myprintf(ctrl, "Something went wrong with the where local matching! %"PRIDX" %"PRIDX"\n", cwhere[cnvtxs], where[u]);
for (j=xadj[u]; j<xadj[u+1]; j++) {
k = cmap[adjncy[j]];
if (k != cfirstvtx+cnvtxs) { /* If this is not an internal edge */
l = k&MASK;
if (htable[l] == -1) { /* Seeing this for first time */
htable[l] = k;
htableidx[l] = cnedges+nedges;
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges++] = adjwgt[j];
}
else if (htable[l] == k) {
cadjwgt[htableidx[l]] += adjwgt[j];
}
else { /* Now you have to go and do a search. Expensive case */
for (l=0; l<nedges; l++) {
if (cadjncy[cnedges+l] == k)
break;
}
if (l < nedges) {
cadjwgt[cnedges+l] += adjwgt[j];
}
else {
cadjncy[cnedges+nedges] = k;
cadjwgt[cnedges+nedges++] = adjwgt[j];
}
}
}
}
}
cnedges += nedges;
for (j=cxadj[cnvtxs]; j<cnedges; j++)
htable[cadjncy[j]&MASK] = -1; /* reset the htable */
cxadj[++cnvtxs] = cnedges;
}
cgraph->nedges = cnedges;
for (j=0; j<cnvtxs; j++) {
for (h=0; h<ncon; h++)
cgraph->nvwgt[j*ncon+h] = ctrl->invtvwgts[h]*cvwgt[j*ncon+h];
}
cgraph->adjncy = imalloc(cnedges, "CreateCoarserGraph: cadjncy");
cgraph->adjwgt = imalloc(cnedges, "CreateCoarserGraph: cadjwgt");
icopy(cnedges, cadjncy, cgraph->adjncy);
icopy(cnedges, cadjwgt, cgraph->adjwgt);
WCOREPOP;
/* Note that graph->where works fine even if it is NULL */
gk_free((void **)&graph->where, LTERM);
}
void GrowKWayPartitioning(ctrl_t *ctrl, graph_t *graph)
{
idx_t v, i, ii, j, nvtxs, nparts, nmis, minvwgt;
idx_t *xadj, *adjncy, *vwgt, *adjwgt;
idx_t *where, *pwgts, *minwgt, *maxwgt, *nbrwgt;
idx_t *perm;
real_t ubfactor_original;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
vwgt = graph->vwgt;
where = graph->where;
pwgts = graph->pwgts;
nparts = ctrl->nparts;
/* setup the weight intervals of the various subdomains */
minwgt = iwspacemalloc(ctrl, nparts);
maxwgt = iwspacemalloc(ctrl, nparts);
for (i=0; i<nparts; i++) {
maxwgt[i] = ctrl->tpwgts[i]*graph->tvwgt[0]*ctrl->ubfactors[0];
minwgt[i] = ctrl->tpwgts[i]*graph->tvwgt[0]*(1.0/ctrl->ubfactors[0]);
}
/* setup the initial state of the partitioning */
iset(nvtxs, nparts, where);
iset(nparts, 0, pwgts);
perm = iwspacemalloc(ctrl, nvtxs);
/* compute the weights of the neighborhood */
nbrwgt = iwspacemalloc(ctrl, nvtxs);
/*
for (i=0; i<nvtxs; i++) {
nbrwgt[i] = vwgt[i];
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
nbrwgt[i] += vwgt[ii]/log2(2+xadj[ii+1]-xadj[ii]);
}
}
*/
for (i=0; i<nvtxs; i++) {
nbrwgt[i] = 0;
for (j=xadj[i]; j<xadj[i+1]; j++)
nbrwgt[i] += adjwgt[j];
}
minvwgt = isum(nvtxs, nbrwgt, 1)/nvtxs;
#ifdef XXX
perm = iwspacemalloc(ctrl, nvtxs);
tperm = iwspacemalloc(ctrl, nvtxs);
degrees = iwspacemalloc(ctrl, nvtxs);
irandArrayPermute(nvtxs, tperm, nvtxs, 1);
irandArrayPermute(nvtxs, tperm, nvtxs, 0);
avgdegree = 1.0*(xadj[nvtxs]/nvtxs);
for (i=0; i<nvtxs; i++) {
bnum = sqrt(1+xadj[i+1]-xadj[i]);
degrees[i] = (bnum > avgdegree ? avgdegree : bnum);
}
BucketSortKeysInc(ctrl, nvtxs, avgdegree, degrees, tperm, perm);
#endif
ubfactor_original = ctrl->ubfactors[0];
ctrl->ubfactors[0] = 1.05*ubfactor_original;
/* find an MIS of vertices by randomly traversing the vertices and assign them to
the different partitions */
irandArrayPermute(nvtxs, perm, nvtxs, 1);
for (nmis=0, ii=0; ii<nvtxs; ii++) {
i=perm[ii];
if (nbrwgt[i] < minvwgt)
continue;
if (where[i] == nparts) {
pwgts[nmis] = vwgt[i];
where[i] = nmis++;
/* mark first level neighbors */
for (j=xadj[i]; j<xadj[i+1]; j++) {
v = adjncy[j];
if (where[v] == nparts)
where[v] = nparts+1;
}
}
if (nmis == nparts)
break;
}
printf(" nvtxs: %"PRIDX", nmis: %"PRIDX", minvwgt: %"PRIDX", ii: %"PRIDX"\n", nvtxs, nmis, minvwgt, ii);
/* if the size of the MIS is not sufficiently large, go and find some additional seeds */
if (nmis < nparts) {
minvwgt = .75*minvwgt;
irandArrayPermute(nvtxs, perm, nvtxs, 0);
for (ii=0; ii<nvtxs; ii++) {
i=perm[ii];
if (nbrwgt[i] < minvwgt)
continue;
if (where[i] == nparts) {
pwgts[nmis] = vwgt[i];
where[i] = nmis++;
/* mark first level neighbors */
for (j=xadj[i]; j<xadj[i+1]; j++) {
v = adjncy[j];
if (where[v] == nparts)
where[v] = nparts+1;
}
}
if (nmis == nparts)
break;
}
printf(" nvtxs: %"PRIDX", nmis: %"PRIDX"\n", nvtxs, nmis);
}
/* if the size of the MIS is not sufficiently large, go and find some additional seeds */
if (nmis < nparts) {
irandArrayPermute(nvtxs, perm, nvtxs, 0);
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (where[i] == nparts+1) {
pwgts[nmis] = vwgt[i];
where[i] = nmis++;
}
if (nmis == nparts)
break;
}
printf(" nvtxs: %"PRIDX", nmis: %"PRIDX"\n", nvtxs, nmis);
}
/* set all unassigned vertices to 'nparts' */
for (i=0; i<nvtxs; i++) {
if (where[i] >= nparts)
where[i] = nparts;
}
WCOREPOP;
/* refine the partition */
ComputeKWayPartitionParams(ctrl, graph);
if (ctrl->minconn)
EliminateSubDomainEdges(ctrl, graph);
for (i=0; i<4; i++) {
ComputeKWayBoundary(ctrl, graph, BNDTYPE_BALANCE);
Greedy_KWayOptimize(ctrl, graph, 10, 0, OMODE_BALANCE);
/*
for (k=0; k<nparts; k++)
printf("%"PRIDX"\n", graph->pwgts[k]);
exit(0);
*/
ComputeKWayBoundary(ctrl, graph, BNDTYPE_REFINE);
Greedy_KWayOptimize(ctrl, graph, ctrl->niter, 1, OMODE_REFINE);
Greedy_KWayEdgeCutOptimize(ctrl, graph, ctrl->niter);
}
ctrl->ubfactors[0] = ubfactor_original;
}
void FM_2WayNodeRefine2Sided(ctrl_t *ctrl, graph_t *graph, idx_t niter)
{
idx_t i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
idx_t *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idx_t *mptr, *mind, *moved, *swaps;
rpq_t *queues[2];
nrinfo_t *rinfo;
idx_t higain, oldgain, mincut, initcut, mincutorder;
idx_t pass, to, other, limit;
idx_t badmaxpwgt, mindiff, newdiff;
idx_t u[2], g[2];
real_t mult;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
vwgt = graph->vwgt;
bndind = graph->bndind;
bndptr = graph->bndptr;
where = graph->where;
pwgts = graph->pwgts;
rinfo = graph->nrinfo;
queues[0] = rpqCreate(nvtxs);
queues[1] = rpqCreate(nvtxs);
moved = iwspacemalloc(ctrl, nvtxs);
swaps = iwspacemalloc(ctrl, nvtxs);
mptr = iwspacemalloc(ctrl, nvtxs+1);
mind = iwspacemalloc(ctrl, 2*nvtxs);
mult = 0.5*ctrl->ubfactors[0];
badmaxpwgt = (idx_t)(mult*(pwgts[0]+pwgts[1]+pwgts[2]));
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
printf("Partitions-N2: [%6"PRIDX" %6"PRIDX"] Nv-Nb[%6"PRIDX" %6"PRIDX"]. ISep: %6"PRIDX"\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
for (pass=0; pass<niter; pass++) {
iset(nvtxs, -1, moved);
rpqReset(queues[0]);
rpqReset(queues[1]);
mincutorder = -1;
initcut = mincut = graph->mincut;
nbnd = graph->nbnd;
/* use the swaps array in place of the traditional perm array to save memory */
my_irandArrayPermute_r(nbnd, swaps, nbnd, 1, &ctrl->curseed);
for (ii=0; ii<nbnd; ii++) {
i = bndind[swaps[ii]];
ASSERT(where[i] == 2);
rpqInsert(queues[0], i, vwgt[i]-rinfo[i].edegrees[1]);
rpqInsert(queues[1], i, vwgt[i]-rinfo[i].edegrees[0]);
}
ASSERT(CheckNodeBnd(graph, nbnd));
ASSERT(CheckNodePartitionParams(graph));
limit = (ctrl->compress ? gk_min(5*nbnd, 400) : gk_min(2*nbnd, 300));
/******************************************************
* Get into the FM loop
*******************************************************/
mptr[0] = nmind = 0;
mindiff = iabs(pwgts[0]-pwgts[1]);
to = (pwgts[0] < pwgts[1] ? 0 : 1);
for (nswaps=0; nswaps<nvtxs; nswaps++) {
u[0] = rpqSeeTopVal(queues[0]);
u[1] = rpqSeeTopVal(queues[1]);
if (u[0] != -1 && u[1] != -1) {
g[0] = vwgt[u[0]]-rinfo[u[0]].edegrees[1];
g[1] = vwgt[u[1]]-rinfo[u[1]].edegrees[0];
to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : pass%2));
if (pwgts[to]+vwgt[u[to]] > badmaxpwgt)
to = (to+1)%2;
}
else if (u[0] == -1 && u[1] == -1) {
break;
}
else if (u[0] != -1 && pwgts[0]+vwgt[u[0]] <= badmaxpwgt) {
to = 0;
}
else if (u[1] != -1 && pwgts[1]+vwgt[u[1]] <= badmaxpwgt) {
to = 1;
}
else
break;
other = (to+1)%2;
higain = rpqGetTop(queues[to]);
if (moved[higain] == -1) /* Delete if it was in the separator originally */
rpqDelete(queues[other], higain);
ASSERT(bndptr[higain] != -1);
/* The following check is to ensure we break out if there is a posibility
of over-running the mind array. */
if (nmind + xadj[higain+1]-xadj[higain] >= 2*nvtxs-1)
break;
pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
newdiff = iabs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other]));
if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) {
mincut = pwgts[2];
mincutorder = nswaps;
mindiff = newdiff;
}
else {
if (nswaps - mincutorder > 2*limit ||
(nswaps - mincutorder > limit && pwgts[2] > 1.10*mincut)) {
pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]);
break; /* No further improvement, break out */
}
}
BNDDelete(nbnd, bndind, bndptr, higain);
pwgts[to] += vwgt[higain];
where[higain] = to;
moved[higain] = nswaps;
swaps[nswaps] = higain;
/**********************************************************
* Update the degrees of the affected nodes
***********************************************************/
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
oldgain = vwgt[k]-rinfo[k].edegrees[to];
rinfo[k].edegrees[to] += vwgt[higain];
if (moved[k] == -1 || moved[k] == -(2+other))
rpqUpdate(queues[other], k, oldgain-vwgt[higain]);
}
else if (where[k] == other) { /* This vertex is pulled into the separator */
ASSERTP(bndptr[k] == -1, ("%"PRIDX" %"PRIDX" %"PRIDX"\n", k, bndptr[k], where[k]));
BNDInsert(nbnd, bndind, bndptr, k);
mind[nmind++] = k; /* Keep track for rollback */
where[k] = 2;
pwgts[other] -= vwgt[k];
edegrees = rinfo[k].edegrees;
edegrees[0] = edegrees[1] = 0;
for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
kk = adjncy[jj];
if (where[kk] != 2)
edegrees[where[kk]] += vwgt[kk];
else {
oldgain = vwgt[kk]-rinfo[kk].edegrees[other];
rinfo[kk].edegrees[other] -= vwgt[k];
if (moved[kk] == -1 || moved[kk] == -(2+to))
rpqUpdate(queues[to], kk, oldgain+vwgt[k]);
}
}
/* Insert the new vertex into the priority queue. Only one side! */
if (moved[k] == -1) {
rpqInsert(queues[to], k, vwgt[k]-edegrees[other]);
moved[k] = -(2+to);
}
}
}
mptr[nswaps+1] = nmind;
IFSET(ctrl->dbglvl, METIS_DBG_MOVEINFO,
printf("Moved %6"PRIDX" to %3"PRIDX", Gain: %5"PRIDX" [%5"PRIDX"] [%4"PRIDX" %4"PRIDX"] \t[%5"PRIDX" %5"PRIDX" %5"PRIDX"]\n", higain, to, g[to], g[other], vwgt[u[to]], vwgt[u[other]], pwgts[0], pwgts[1], pwgts[2]));
}
/****************************************************************
* Roll back computation
*****************************************************************/
for (nswaps--; nswaps>mincutorder; nswaps--) {
higain = swaps[nswaps];
ASSERT(CheckNodePartitionParams(graph));
to = where[higain];
other = (to+1)%2;
INC_DEC(pwgts[2], pwgts[to], vwgt[higain]);
where[higain] = 2;
BNDInsert(nbnd, bndind, bndptr, higain);
edegrees = rinfo[higain].edegrees;
edegrees[0] = edegrees[1] = 0;
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
if (where[k] == 2)
rinfo[k].edegrees[to] -= vwgt[higain];
else
edegrees[where[k]] += vwgt[k];
}
/* Push nodes out of the separator */
for (j=mptr[nswaps]; j<mptr[nswaps+1]; j++) {
k = mind[j];
ASSERT(where[k] == 2);
where[k] = other;
INC_DEC(pwgts[other], pwgts[2], vwgt[k]);
BNDDelete(nbnd, bndind, bndptr, k);
for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
kk = adjncy[jj];
if (where[kk] == 2)
rinfo[kk].edegrees[other] += vwgt[k];
}
}
}
ASSERT(mincut == pwgts[2]);
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
printf("\tMinimum sep: %6"PRIDX" at %5"PRIDX", PWGTS: [%6"PRIDX" %6"PRIDX"], NBND: %6"PRIDX"\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
graph->mincut = mincut;
graph->nbnd = nbnd;
if (mincutorder == -1 || mincut >= initcut)
break;
}
rpqDestroy(queues[0]);
rpqDestroy(queues[1]);
WCOREPOP;
}
/*************************************************************************
* This function is the entry point of the initial partition algorithm
* that does recursive bissection.
* This algorithm assembles the graph to all the processors and preceeds
* by parallelizing the recursive bisection step.
**************************************************************************/
void InitPartition(ctrl_t *ctrl, graph_t *graph)
{
idx_t i, j, ncon, mype, npes, gnvtxs, ngroups;
idx_t *xadj, *adjncy, *adjwgt, *vwgt;
idx_t *part, *gwhere0, *gwhere1;
idx_t *tmpwhere, *tmpvwgt, *tmpxadj, *tmpadjncy, *tmpadjwgt;
graph_t *agraph;
idx_t lnparts, fpart, fpe, lnpes;
idx_t twoparts=2, moptions[METIS_NOPTIONS], edgecut, max_cut;
real_t *tpwgts, *tpwgts2, *lbvec, lbsum, min_lbsum, wsum;
MPI_Comm ipcomm;
struct {
double sum;
int rank;
} lpesum, gpesum;
WCOREPUSH;
ncon = graph->ncon;
ngroups = gk_max(gk_min(RIP_SPLIT_FACTOR, ctrl->npes), 1);
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->comm));
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
lbvec = rwspacemalloc(ctrl, ncon);
/* assemble the graph to all the processors */
agraph = AssembleAdaptiveGraph(ctrl, graph);
gnvtxs = agraph->nvtxs;
/* make a copy of the graph's structure for later */
xadj = icopy(gnvtxs+1, agraph->xadj, iwspacemalloc(ctrl, gnvtxs+1));
vwgt = icopy(gnvtxs*ncon, agraph->vwgt, iwspacemalloc(ctrl, gnvtxs*ncon));
adjncy = icopy(agraph->nedges, agraph->adjncy, iwspacemalloc(ctrl, agraph->nedges));
adjwgt = icopy(agraph->nedges, agraph->adjwgt, iwspacemalloc(ctrl, agraph->nedges));
part = iwspacemalloc(ctrl, gnvtxs);
/* create different processor groups */
gkMPI_Comm_split(ctrl->gcomm, ctrl->mype % ngroups, 0, &ipcomm);
gkMPI_Comm_rank(ipcomm, &mype);
gkMPI_Comm_size(ipcomm, &npes);
/* Go into the recursive bisection */
METIS_SetDefaultOptions(moptions);
moptions[METIS_OPTION_SEED] = ctrl->sync + (ctrl->mype % ngroups) + 1;
tpwgts = ctrl->tpwgts;
tpwgts2 = rwspacemalloc(ctrl, 2*ncon);
lnparts = ctrl->nparts;
fpart = fpe = 0;
lnpes = npes;
while (lnpes > 1 && lnparts > 1) {
/* determine the weights of the two partitions as a function of the
weight of the target partition weights */
for (j=(lnparts>>1), i=0; i<ncon; i++) {
tpwgts2[i] = rsum(j, tpwgts+fpart*ncon+i, ncon);
tpwgts2[ncon+i] = rsum(lnparts-j, tpwgts+(fpart+j)*ncon+i, ncon);
wsum = 1.0/(tpwgts2[i] + tpwgts2[ncon+i]);
tpwgts2[i] *= wsum;
tpwgts2[ncon+i] *= wsum;
}
METIS_PartGraphRecursive(&agraph->nvtxs, &ncon, agraph->xadj, agraph->adjncy,
agraph->vwgt, NULL, agraph->adjwgt, &twoparts, tpwgts2, NULL, moptions,
&edgecut, part);
/* pick one of the branches */
if (mype < fpe+lnpes/2) {
KeepPart(ctrl, agraph, part, 0);
lnpes = lnpes/2;
lnparts = lnparts/2;
}
else {
KeepPart(ctrl, agraph, part, 1);
fpart = fpart + lnparts/2;
fpe = fpe + lnpes/2;
lnpes = lnpes - lnpes/2;
lnparts = lnparts - lnparts/2;
}
}
gwhere0 = iset(gnvtxs, 0, iwspacemalloc(ctrl, gnvtxs));
gwhere1 = iwspacemalloc(ctrl, gnvtxs);
if (lnparts == 1) { /* Case npes is greater than or equal to nparts */
/* Only the first process will assign labels (for the reduction to work) */
if (mype == fpe) {
for (i=0; i<agraph->nvtxs; i++)
gwhere0[agraph->label[i]] = fpart;
}
}
else { /* Case in which npes is smaller than nparts */
/* create the normalized tpwgts for the lnparts from ctrl->tpwgts */
tpwgts = rwspacemalloc(ctrl, lnparts*ncon);
for (j=0; j<ncon; j++) {
for (wsum=0.0, i=0; i<lnparts; i++) {
tpwgts[i*ncon+j] = ctrl->tpwgts[(fpart+i)*ncon+j];
wsum += tpwgts[i*ncon+j];
}
for (wsum=1.0/wsum, i=0; i<lnparts; i++)
tpwgts[i*ncon+j] *= wsum;
}
METIS_PartGraphKway(&agraph->nvtxs, &ncon, agraph->xadj, agraph->adjncy,
agraph->vwgt, NULL, agraph->adjwgt, &lnparts, tpwgts, NULL, moptions,
&edgecut, part);
for (i=0; i<agraph->nvtxs; i++)
gwhere0[agraph->label[i]] = fpart + part[i];
}
gkMPI_Allreduce((void *)gwhere0, (void *)gwhere1, gnvtxs, IDX_T, MPI_SUM, ipcomm);
if (ngroups > 1) {
tmpxadj = agraph->xadj;
tmpadjncy = agraph->adjncy;
tmpadjwgt = agraph->adjwgt;
tmpvwgt = agraph->vwgt;
tmpwhere = agraph->where;
agraph->xadj = xadj;
agraph->adjncy = adjncy;
agraph->adjwgt = adjwgt;
agraph->vwgt = vwgt;
agraph->where = gwhere1;
agraph->vwgt = vwgt;
agraph->nvtxs = gnvtxs;
edgecut = ComputeSerialEdgeCut(agraph);
ComputeSerialBalance(ctrl, agraph, gwhere1, lbvec);
lbsum = rsum(ncon, lbvec, 1);
gkMPI_Allreduce((void *)&edgecut, (void *)&max_cut, 1, IDX_T, MPI_MAX, ctrl->gcomm);
gkMPI_Allreduce((void *)&lbsum, (void *)&min_lbsum, 1, REAL_T, MPI_MIN, ctrl->gcomm);
lpesum.sum = lbsum;
if (min_lbsum < UNBALANCE_FRACTION*ncon) {
if (lbsum < UNBALANCE_FRACTION*ncon)
lpesum.sum = edgecut;
else
lpesum.sum = max_cut;
}
lpesum.rank = ctrl->mype;
gkMPI_Allreduce((void *)&lpesum, (void *)&gpesum, 1, MPI_DOUBLE_INT,
MPI_MINLOC, ctrl->gcomm);
gkMPI_Bcast((void *)gwhere1, gnvtxs, IDX_T, gpesum.rank, ctrl->gcomm);
agraph->xadj = tmpxadj;
agraph->adjncy = tmpadjncy;
agraph->adjwgt = tmpadjwgt;
agraph->vwgt = tmpvwgt;
agraph->where = tmpwhere;
}
icopy(graph->nvtxs, gwhere1+graph->vtxdist[ctrl->mype], graph->where);
FreeGraph(agraph);
gkMPI_Comm_free(&ipcomm);
IFSET(ctrl->dbglvl, DBG_TIME, gkMPI_Barrier(ctrl->comm));
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
WCOREPOP;
}
void FM_2WayNodeRefine1Sided(ctrl_t *ctrl, graph_t *graph, idx_t niter)
{
idx_t i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind, iend;
idx_t *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idx_t *mptr, *mind, *swaps;
rpq_t *queue;
nrinfo_t *rinfo;
idx_t higain, mincut, initcut, mincutorder;
idx_t pass, to, other, limit;
idx_t badmaxpwgt, mindiff, newdiff;
real_t mult;
WCOREPUSH;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
vwgt = graph->vwgt;
bndind = graph->bndind;
bndptr = graph->bndptr;
where = graph->where;
pwgts = graph->pwgts;
rinfo = graph->nrinfo;
queue = rpqCreate(nvtxs);
swaps = iwspacemalloc(ctrl, nvtxs);
mptr = iwspacemalloc(ctrl, nvtxs+1);
mind = iwspacemalloc(ctrl, 2*nvtxs);
mult = 0.5*ctrl->ubfactors[0];
badmaxpwgt = (idx_t)(mult*(pwgts[0]+pwgts[1]+pwgts[2]));
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
printf("Partitions-N1: [%6"PRIDX" %6"PRIDX"] Nv-Nb[%6"PRIDX" %6"PRIDX"]. ISep: %6"PRIDX"\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
to = (pwgts[0] < pwgts[1] ? 1 : 0);
for (pass=0; pass<2*niter; pass++) { /* the 2*niter is for the two sides */
other = to;
to = (to+1)%2;
rpqReset(queue);
mincutorder = -1;
initcut = mincut = graph->mincut;
nbnd = graph->nbnd;
/* use the swaps array in place of the traditional perm array to save memory */
my_irandArrayPermute_r(nbnd, swaps, nbnd, 1, &ctrl->curseed);
for (ii=0; ii<nbnd; ii++) {
i = bndind[swaps[ii]];
ASSERT(where[i] == 2);
rpqInsert(queue, i, vwgt[i]-rinfo[i].edegrees[other]);
}
ASSERT(CheckNodeBnd(graph, nbnd));
ASSERT(CheckNodePartitionParams(graph));
limit = (ctrl->compress ? gk_min(5*nbnd, 500) : gk_min(3*nbnd, 300));
/******************************************************
* Get into the FM loop
*******************************************************/
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startwctimer(ctrl->Aux3Tmr));
mptr[0] = nmind = 0;
mindiff = iabs(pwgts[0]-pwgts[1]);
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if ((higain = rpqGetTop(queue)) == -1)
break;
ASSERT(bndptr[higain] != -1);
/* The following check is to ensure we break out if there is a posibility
of over-running the mind array. */
if (nmind + xadj[higain+1]-xadj[higain] >= 2*nvtxs-1)
break;
if (pwgts[to]+vwgt[higain] > badmaxpwgt)
break; /* No point going any further. Balance will be bad */
pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
newdiff = iabs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other]));
if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) {
mincut = pwgts[2];
mincutorder = nswaps;
mindiff = newdiff;
}
else {
if (nswaps - mincutorder > 3*limit ||
(nswaps - mincutorder > limit && pwgts[2] > 1.10*mincut)) {
pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]);
break; /* No further improvement, break out */
}
}
BNDDelete(nbnd, bndind, bndptr, higain);
pwgts[to] += vwgt[higain];
where[higain] = to;
swaps[nswaps] = higain;
/**********************************************************
* Update the degrees of the affected nodes
***********************************************************/
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startwctimer(ctrl->Aux1Tmr));
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
rinfo[k].edegrees[to] += vwgt[higain];
}
else if (where[k] == other) { /* This vertex is pulled into the separator */
ASSERTP(bndptr[k] == -1, ("%"PRIDX" %"PRIDX" %"PRIDX"\n", k, bndptr[k], where[k]));
BNDInsert(nbnd, bndind, bndptr, k);
mind[nmind++] = k; /* Keep track for rollback */
where[k] = 2;
pwgts[other] -= vwgt[k];
edegrees = rinfo[k].edegrees;
edegrees[0] = edegrees[1] = 0;
for (jj=xadj[k], iend=xadj[k+1]; jj<iend; jj++) {
kk = adjncy[jj];
if (where[kk] != 2)
edegrees[where[kk]] += vwgt[kk];
else {
rinfo[kk].edegrees[other] -= vwgt[k];
/* Since the moves are one-sided this vertex has not been moved yet */
rpqUpdate(queue, kk, vwgt[kk]-rinfo[kk].edegrees[other]);
}
}
/* Insert the new vertex into the priority queue. Safe due to one-sided moves */
rpqInsert(queue, k, vwgt[k]-edegrees[other]);
}
}
mptr[nswaps+1] = nmind;
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopwctimer(ctrl->Aux1Tmr));
IFSET(ctrl->dbglvl, METIS_DBG_MOVEINFO,
printf("Moved %6"PRIDX" to %3"PRIDX", Gain: %5"PRIDX" [%5"PRIDX"] \t[%5"PRIDX" %5"PRIDX" %5"PRIDX"] [%3"PRIDX" %2"PRIDX"]\n",
higain, to, (vwgt[higain]-rinfo[higain].edegrees[other]), vwgt[higain],
pwgts[0], pwgts[1], pwgts[2], nswaps, limit));
}
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopwctimer(ctrl->Aux3Tmr));
/****************************************************************
* Roll back computation
*****************************************************************/
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startwctimer(ctrl->Aux2Tmr));
for (nswaps--; nswaps>mincutorder; nswaps--) {
higain = swaps[nswaps];
ASSERT(CheckNodePartitionParams(graph));
ASSERT(where[higain] == to);
INC_DEC(pwgts[2], pwgts[to], vwgt[higain]);
where[higain] = 2;
BNDInsert(nbnd, bndind, bndptr, higain);
edegrees = rinfo[higain].edegrees;
edegrees[0] = edegrees[1] = 0;
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
if (where[k] == 2)
rinfo[k].edegrees[to] -= vwgt[higain];
else
edegrees[where[k]] += vwgt[k];
}
/* Push nodes out of the separator */
for (j=mptr[nswaps]; j<mptr[nswaps+1]; j++) {
k = mind[j];
ASSERT(where[k] == 2);
where[k] = other;
INC_DEC(pwgts[other], pwgts[2], vwgt[k]);
BNDDelete(nbnd, bndind, bndptr, k);
for (jj=xadj[k], iend=xadj[k+1]; jj<iend; jj++) {
kk = adjncy[jj];
if (where[kk] == 2)
rinfo[kk].edegrees[other] += vwgt[k];
}
}
}
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopwctimer(ctrl->Aux2Tmr));
ASSERT(mincut == pwgts[2]);
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
printf("\tMinimum sep: %6"PRIDX" at %5"PRIDX", PWGTS: [%6"PRIDX" %6"PRIDX"], NBND: %6"PRIDX"\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
graph->mincut = mincut;
graph->nbnd = nbnd;
if (pass%2 == 1 && (mincutorder == -1 || mincut >= initcut))
break;
}
rpqDestroy(queue);
WCOREPOP;
}
void ComputeKWayVolGains(ctrl_t *ctrl, graph_t *graph)
{
idx_t i, ii, j, k, l, nvtxs, nparts, me, other, pid;
idx_t *xadj, *vsize, *adjncy, *where,
*bndind, *bndptr, *ophtable;
vkrinfo_t *myrinfo, *orinfo;
vnbr_t *mynbrs, *onbrs;
WCOREPUSH;
nparts = ctrl->nparts;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vsize = graph->vsize;
adjncy = graph->adjncy;
where = graph->where;
bndind = graph->bndind;
bndptr = iset(nvtxs, -1, graph->bndptr);
ophtable = iset(nparts, -1, iwspacemalloc(ctrl, nparts));
/* Compute the volume gains */
graph->minvol = graph->nbnd = 0;
for (i=0; i<nvtxs; i++) {
myrinfo = graph->vkrinfo+i;
myrinfo->gv = IDX_MIN;
if (myrinfo->nnbrs > 0) {
me = where[i];
mynbrs = ctrl->vnbrpool + myrinfo->inbr;
graph->minvol += myrinfo->nnbrs*vsize[i];
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
other = where[ii];
orinfo = graph->vkrinfo+ii;
onbrs = ctrl->vnbrpool + orinfo->inbr;
for (k=0; k<orinfo->nnbrs; k++)
ophtable[onbrs[k].pid] = k;
ophtable[other] = 1; /* this is to simplify coding */
if (me == other) {
/* Find which domains 'i' is connected to but 'ii' is not
and update their gain */
for (k=0; k<myrinfo->nnbrs; k++) {
if (ophtable[mynbrs[k].pid] == -1)
mynbrs[k].gv -= vsize[ii];
}
}
else {
ASSERT(ophtable[me] != -1);
if (onbrs[ophtable[me]].ned == 1) {
/* I'm the only connection of 'ii' in 'me' */
/* Increase the gains for all the common domains between 'i' and 'ii' */
for (k=0; k<myrinfo->nnbrs; k++) {
if (ophtable[mynbrs[k].pid] != -1)
mynbrs[k].gv += vsize[ii];
}
}
else {
/* Find which domains 'i' is connected to and 'ii' is not
and update their gain */
for (k=0; k<myrinfo->nnbrs; k++) {
if (ophtable[mynbrs[k].pid] == -1)
mynbrs[k].gv -= vsize[ii];
}
}
}
/* Reset the marker vector */
for (k=0; k<orinfo->nnbrs; k++)
ophtable[onbrs[k].pid] = -1;
ophtable[other] = -1;
}
/* Compute the max vgain */
for (k=0; k<myrinfo->nnbrs; k++) {
if (mynbrs[k].gv > myrinfo->gv)
myrinfo->gv = mynbrs[k].gv;
}
/* Add the extra gain due to id == 0 */
if (myrinfo->ned > 0 && myrinfo->nid == 0)
myrinfo->gv += vsize[i];
}
if (myrinfo->gv >= 0)
BNDInsert(graph->nbnd, bndind, bndptr, i);
}
WCOREPOP;
}
void FM_2WayNodeBalance(ctrl_t *ctrl, graph_t *graph)
{
idx_t i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, gain;
idx_t badmaxpwgt, higain, oldgain, to, other;
idx_t *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idx_t *perm, *moved;
rpq_t *queue;
nrinfo_t *rinfo;
real_t mult;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
vwgt = graph->vwgt;
bndind = graph->bndind;
bndptr = graph->bndptr;
where = graph->where;
pwgts = graph->pwgts;
rinfo = graph->nrinfo;
mult = 0.5*ctrl->ubfactors[0];
badmaxpwgt = (idx_t)(mult*(pwgts[0]+pwgts[1]));
if (gk_max(pwgts[0], pwgts[1]) < badmaxpwgt)
return;
if (iabs(pwgts[0]-pwgts[1]) < 3*graph->tvwgt[0]/nvtxs)
return;
WCOREPUSH;
to = (pwgts[0] < pwgts[1] ? 0 : 1);
other = (to+1)%2;
queue = rpqCreate(nvtxs);
perm = iwspacemalloc(ctrl, nvtxs);
moved = iset(nvtxs, -1, iwspacemalloc(ctrl, nvtxs));
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
printf("Partitions: [%6"PRIDX" %6"PRIDX"] Nv-Nb[%6"PRIDX" %6"PRIDX"]. ISep: %6"PRIDX" [B]\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
nbnd = graph->nbnd;
my_irandArrayPermute_r(nbnd, perm, nbnd, 1, &ctrl->curseed);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(where[i] == 2);
rpqInsert(queue, i, vwgt[i]-rinfo[i].edegrees[other]);
}
ASSERT(CheckNodeBnd(graph, nbnd));
ASSERT(CheckNodePartitionParams(graph));
/******************************************************
* Get into the FM loop
*******************************************************/
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if ((higain = rpqGetTop(queue)) == -1)
break;
moved[higain] = 1;
gain = vwgt[higain]-rinfo[higain].edegrees[other];
badmaxpwgt = (idx_t)(mult*(pwgts[0]+pwgts[1]));
/* break if other is now underwight */
if (pwgts[to] > pwgts[other])
break;
/* break if balance is achieved and no +ve or zero gain */
if (gain < 0 && pwgts[other] < badmaxpwgt)
break;
/* skip this vertex if it will violate balance on the other side */
if (pwgts[to]+vwgt[higain] > badmaxpwgt)
continue;
ASSERT(bndptr[higain] != -1);
pwgts[2] -= gain;
BNDDelete(nbnd, bndind, bndptr, higain);
pwgts[to] += vwgt[higain];
where[higain] = to;
IFSET(ctrl->dbglvl, METIS_DBG_MOVEINFO,
printf("Moved %6"PRIDX" to %3"PRIDX", Gain: %3"PRIDX", \t[%5"PRIDX" %5"PRIDX" %5"PRIDX"]\n", higain, to, vwgt[higain]-rinfo[higain].edegrees[other], pwgts[0], pwgts[1], pwgts[2]));
/**********************************************************
* Update the degrees of the affected nodes
***********************************************************/
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
rinfo[k].edegrees[to] += vwgt[higain];
}
else if (where[k] == other) { /* This vertex is pulled into the separator */
ASSERTP(bndptr[k] == -1, ("%"PRIDX" %"PRIDX" %"PRIDX"\n", k, bndptr[k], where[k]));
BNDInsert(nbnd, bndind, bndptr, k);
where[k] = 2;
pwgts[other] -= vwgt[k];
edegrees = rinfo[k].edegrees;
edegrees[0] = edegrees[1] = 0;
for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
kk = adjncy[jj];
if (where[kk] != 2)
edegrees[where[kk]] += vwgt[kk];
else {
ASSERT(bndptr[kk] != -1);
oldgain = vwgt[kk]-rinfo[kk].edegrees[other];
rinfo[kk].edegrees[other] -= vwgt[k];
if (moved[kk] == -1)
rpqUpdate(queue, kk, oldgain+vwgt[k]);
}
}
/* Insert the new vertex into the priority queue */
rpqInsert(queue, k, vwgt[k]-edegrees[other]);
}
}
}
IFSET(ctrl->dbglvl, METIS_DBG_REFINE,
printf("\tBalanced sep: %6"PRIDX" at %4"PRIDX", PWGTS: [%6"PRIDX" %6"PRIDX"], NBND: %6"PRIDX"\n", pwgts[2], nswaps, pwgts[0], pwgts[1], nbnd));
graph->mincut = pwgts[2];
graph->nbnd = nbnd;
rpqDestroy(queue);
WCOREPOP;
}
