void MoveGroupContigForVol(ctrl_t *ctrl, graph_t *graph, idx_t to, idx_t gid,
idx_t *ptr, idx_t *ind, idx_t *vmarker, idx_t *pmarker,
idx_t *modind) {
idx_t i, ii, iii, j, jj, k, l, nvtxs, from, me, other, xgain;
idx_t *xadj, *vsize, *adjncy, *where;
vkrinfo_t *myrinfo, *orinfo;
vnbr_t *mynbrs, *onbrs;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vsize = graph->vsize;
adjncy = graph->adjncy;
where = graph->where;
for (iii = ptr[gid]; iii < ptr[gid + 1]; iii++) {
i = ind[iii];
from = where[i];
myrinfo = graph->vkrinfo + i;
if (myrinfo->inbr == -1) {
myrinfo->inbr = vnbrpoolGetNext(ctrl, xadj[i + 1] - xadj[i] + 1);
myrinfo->nnbrs = 0;
}
mynbrs = ctrl->vnbrpool + myrinfo->inbr;
xgain = (myrinfo->nid == 0 && myrinfo->ned > 0 ? vsize[i] : 0);
/* find the location of 'to' in myrinfo or create it if it is not there */
for (k = 0; k < myrinfo->nnbrs; k++) {
if (mynbrs[k].pid == to) {
break;
}
}
if (k == myrinfo->nnbrs) {
if (myrinfo->nid > 0) {
xgain -= vsize[i];
}
/* determine the volume gain resulting from that move */
for (j = xadj[i]; j < xadj[i + 1]; j++) {
ii = adjncy[j];
other = where[ii];
orinfo = graph->vkrinfo + ii;
onbrs = ctrl->vnbrpool + orinfo->inbr;
ASSERT(other != to)
if (from == other) {
/* Same subdomain vertex: Decrease the gain if 'to' is a new neighbor. */
for (l = 0; l < orinfo->nnbrs; l++) {
if (onbrs[l].pid == to) {
break;
}
}
if (l == orinfo->nnbrs) {
xgain -= vsize[ii];
}
} else {
/* Remote vertex: increase if 'to' is a new subdomain */
for (l = 0; l < orinfo->nnbrs; l++) {
if (onbrs[l].pid == to) {
break;
}
}
if (l == orinfo->nnbrs) {
xgain -= vsize[ii];
}
/* Remote vertex: decrease if i is the only connection to 'from' */
for (l = 0; l < orinfo->nnbrs; l++) {
if (onbrs[l].pid == from && onbrs[l].ned == 1) {
xgain += vsize[ii];
break;
}
}
}
}
graph->minvol -= xgain;
graph->mincut -= -myrinfo->nid;
} else {
graph->minvol -= (xgain + mynbrs[k].gv);
graph->mincut -= mynbrs[k].ned - myrinfo->nid;
}
/* Update where and pwgts */
where[i] = to;
iaxpy(graph->ncon, 1, graph->vwgt + i * graph->ncon, 1, graph->pwgts + to * graph->ncon, 1);
iaxpy(graph->ncon, -1, graph->vwgt + i * graph->ncon, 1, graph->pwgts + from * graph->ncon, 1);
/* Update the id/ed/gains/bnd of potentially affected nodes */
KWayVolUpdate(ctrl, graph, i, from, to, NULL, NULL, NULL, NULL,
NULL, BNDTYPE_REFINE, vmarker, pmarker, modind);
/*CheckKWayVolPartitionParams(ctrl, graph);*/
}
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 MoveGroupContigForCut(ctrl_t *ctrl, graph_t *graph, idx_t to, idx_t gid,
idx_t *ptr, idx_t *ind) {
idx_t i, ii, iii, j, jj, k, l, nvtxs, nbnd, from, me;
idx_t *xadj, *adjncy, *adjwgt, *where, *bndptr, *bndind;
ckrinfo_t *myrinfo;
cnbr_t *mynbrs;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
bndptr = graph->bndptr;
bndind = graph->bndind;
nbnd = graph->nbnd;
for (iii = ptr[gid]; iii < ptr[gid + 1]; iii++) {
i = ind[iii];
from = where[i];
myrinfo = graph->ckrinfo + i;
if (myrinfo->inbr == -1) {
myrinfo->inbr = cnbrpoolGetNext(ctrl, xadj[i + 1] - xadj[i] + 1);
myrinfo->nnbrs = 0;
}
mynbrs = ctrl->cnbrpool + myrinfo->inbr;
/* find the location of 'to' in myrinfo or create it if it is not there */
for (k = 0; k < myrinfo->nnbrs; k++) {
if (mynbrs[k].pid == to) {
break;
}
}
if (k == myrinfo->nnbrs) {
mynbrs[k].pid = to;
mynbrs[k].ed = 0;
myrinfo->nnbrs++;
}
graph->mincut -= mynbrs[k].ed - myrinfo->id;
/* Update ID/ED and BND related information for the moved vertex */
iaxpy(graph->ncon, 1, graph->vwgt + i * graph->ncon, 1, graph->pwgts + to * graph->ncon, 1);
iaxpy(graph->ncon, -1, graph->vwgt + i * graph->ncon, 1, graph->pwgts + from * graph->ncon, 1);
UpdateMovedVertexInfoAndBND(i, from, k, to, myrinfo, mynbrs, where, nbnd,
bndptr, bndind, BNDTYPE_REFINE);
/* Update the degrees of adjacent vertices */
for (j = xadj[i]; j < xadj[i + 1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->ckrinfo + ii;
UpdateAdjacentVertexInfoAndBND(ctrl, ii, xadj[ii + 1] - xadj[ii], me,
from, to, myrinfo, adjwgt[j], nbnd, bndptr, bndind, BNDTYPE_REFINE);
}
ASSERT(CheckRInfo(ctrl, graph->ckrinfo + i));
}
graph->nbnd = nbnd;
}
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 MoveGroupMinConnForVol(ctrl_t *ctrl, graph_t *graph, idx_t to, idx_t nind,
idx_t *ind, idx_t *vmarker, idx_t *pmarker, idx_t *modind)
{
idx_t i, ii, j, jj, k, l, nvtxs, from, me, other, xgain, ewgt;
idx_t *xadj, *vsize, *adjncy, *where;
vkrinfo_t *myrinfo, *orinfo;
vnbr_t *mynbrs, *onbrs;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vsize = graph->vsize;
adjncy = graph->adjncy;
where = graph->where;
while (--nind>=0) {
i = ind[nind];
from = where[i];
myrinfo = graph->vkrinfo+i;
if (myrinfo->inbr == -1) {
myrinfo->inbr = vnbrpoolGetNext(ctrl, xadj[i+1]-xadj[i]+1);
myrinfo->nnbrs = 0;
}
mynbrs = ctrl->vnbrpool + myrinfo->inbr;
xgain = (myrinfo->nid == 0 && myrinfo->ned > 0 ? vsize[i] : 0);
//printf("Moving %"PRIDX" from %"PRIDX" to %"PRIDX" [vsize: %"PRIDX"] [xgain: %"PRIDX"]\n",
// i, from, to, vsize[i], xgain);
/* find the location of 'to' in myrinfo or create it if it is not there */
for (k=0; k<myrinfo->nnbrs; k++) {
if (mynbrs[k].pid == to)
break;
}
if (k == myrinfo->nnbrs) {
//printf("Missing neighbor\n");
if (myrinfo->nid > 0)
xgain -= vsize[i];
/* determine the volume gain resulting from that move */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
other = where[ii];
orinfo = graph->vkrinfo+ii;
onbrs = ctrl->vnbrpool + orinfo->inbr;
ASSERT(other != to)
//printf(" %8d %8d %3d\n", (int)ii, (int)vsize[ii], (int)other);
if (from == other) {
/* Same subdomain vertex: Decrease the gain if 'to' is a new neighbor. */
for (l=0; l<orinfo->nnbrs; l++) {
if (onbrs[l].pid == to)
break;
}
if (l == orinfo->nnbrs)
xgain -= vsize[ii];
}
else {
/* Remote vertex: increase if 'to' is a new subdomain */
for (l=0; l<orinfo->nnbrs; l++) {
if (onbrs[l].pid == to)
break;
}
if (l == orinfo->nnbrs)
xgain -= vsize[ii];
/* Remote vertex: decrease if i is the only connection to 'from' */
for (l=0; l<orinfo->nnbrs; l++) {
if (onbrs[l].pid == from && onbrs[l].ned == 1) {
xgain += vsize[ii];
break;
}
}
}
}
graph->minvol -= xgain;
graph->mincut -= -myrinfo->nid;
ewgt = myrinfo->nid;
}
else {
graph->minvol -= (xgain + mynbrs[k].gv);
graph->mincut -= mynbrs[k].ned-myrinfo->nid;
ewgt = myrinfo->nid-mynbrs[k].ned;
}
/* Update where and pwgts */
where[i] = to;
iaxpy(graph->ncon, 1, graph->vwgt+i*graph->ncon, 1, graph->pwgts+to*graph->ncon, 1);
iaxpy(graph->ncon, -1, graph->vwgt+i*graph->ncon, 1, graph->pwgts+from*graph->ncon, 1);
/* Update subdomain connectivity graph to reflect the move of 'i' */
UpdateEdgeSubDomainGraph(ctrl, from, to, ewgt, NULL);
/* Update the subdomain connectivity of the adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
me = where[adjncy[j]];
if (me != from && me != to) {
UpdateEdgeSubDomainGraph(ctrl, from, me, -1, NULL);
UpdateEdgeSubDomainGraph(ctrl, to, me, 1, NULL);
}
}
/* Update the id/ed/gains/bnd of potentially affected nodes */
KWayVolUpdate(ctrl, graph, i, from, to, NULL, NULL, NULL, NULL,
NULL, BNDTYPE_REFINE, vmarker, pmarker, modind);
/*CheckKWayVolPartitionParams(ctrl, graph);*/
}
void MoveGroupMinConnForCut(ctrl_t *ctrl, graph_t *graph, idx_t to, idx_t nind,
idx_t *ind)
{
idx_t i, ii, j, jj, k, l, nvtxs, nbnd, from, me;
idx_t *xadj, *adjncy, *adjwgt, *where, *bndptr, *bndind;
ckrinfo_t *myrinfo;
cnbr_t *mynbrs;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
bndptr = graph->bndptr;
bndind = graph->bndind;
nbnd = graph->nbnd;
while (--nind>=0) {
i = ind[nind];
from = where[i];
myrinfo = graph->ckrinfo+i;
if (myrinfo->inbr == -1) {
myrinfo->inbr = cnbrpoolGetNext(ctrl, xadj[i+1]-xadj[i]+1);
myrinfo->nnbrs = 0;
}
mynbrs = ctrl->cnbrpool + myrinfo->inbr;
/* find the location of 'to' in myrinfo or create it if it is not there */
for (k=0; k<myrinfo->nnbrs; k++) {
if (mynbrs[k].pid == to)
break;
}
if (k == myrinfo->nnbrs) {
ASSERT(k < xadj[i+1]-xadj[i]);
mynbrs[k].pid = to;
mynbrs[k].ed = 0;
myrinfo->nnbrs++;
}
/* Update pwgts */
iaxpy(graph->ncon, 1, graph->vwgt+i*graph->ncon, 1, graph->pwgts+to*graph->ncon, 1);
iaxpy(graph->ncon, -1, graph->vwgt+i*graph->ncon, 1, graph->pwgts+from*graph->ncon, 1);
/* Update mincut */
graph->mincut -= mynbrs[k].ed-myrinfo->id;
/* Update subdomain connectivity graph to reflect the move of 'i' */
UpdateEdgeSubDomainGraph(ctrl, from, to, myrinfo->id-mynbrs[k].ed, NULL);
/* Update ID/ED and BND related information for the moved vertex */
UpdateMovedVertexInfoAndBND(i, from, k, to, myrinfo, mynbrs, where, nbnd,
bndptr, bndind, BNDTYPE_REFINE);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->ckrinfo+ii;
UpdateAdjacentVertexInfoAndBND(ctrl, ii, xadj[ii+1]-xadj[ii], me,
from, to, myrinfo, adjwgt[j], nbnd, bndptr, bndind, BNDTYPE_REFINE);
/* Update subdomain graph to reflect the move of 'i' for domains other
than 'from' and 'to' */
if (me != from && me != to) {
UpdateEdgeSubDomainGraph(ctrl, from, me, -adjwgt[j], NULL);
UpdateEdgeSubDomainGraph(ctrl, to, me, adjwgt[j], NULL);
}
}
}
ASSERT(ComputeCut(graph, where) == graph->mincut);
graph->nbnd = nbnd;
}
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;
}
