/*************************************************************************
* This function computes the initial id/ed
**************************************************************************/
void Compute2WayNodePartitionParams(CtrlType *ctrl, GraphType *graph)
{
int i, j, k, l, nvtxs, nbnd;
idxtype *xadj, *adjncy, *adjwgt, *vwgt;
idxtype *where, *pwgts, *bndind, *bndptr, *edegrees;
NRInfoType *rinfo;
int me, other;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
rinfo = graph->nrinfo;
pwgts = idxset(3, 0, graph->pwgts);
bndind = graph->bndind;
bndptr = idxset(nvtxs, -1, graph->bndptr);
/*------------------------------------------------------------
/ Compute now the separator external degrees
/------------------------------------------------------------*/
nbnd = 0;
for (i=0; i<nvtxs; i++) {
me = where[i];
pwgts[me] += vwgt[i];
ASSERT(me >=0 && me <= 2);
if (me == 2) { /* If it is on the separator do some computations */
BNDInsert(nbnd, bndind, bndptr, i);
edegrees = rinfo[i].edegrees;
edegrees[0] = edegrees[1] = 0;
for (j=xadj[i]; j<xadj[i+1]; j++) {
other = where[adjncy[j]];
if (other != 2)
edegrees[other] += vwgt[adjncy[j]];
}
}
}
ASSERT(CheckNodeBnd(graph, nbnd));
graph->mincut = pwgts[2];
graph->nbnd = nbnd;
}
/*************************************************************************
* This function performs a node-based FM refinement
**************************************************************************/
void FM_2WayNodeBalance(CtrlType *ctrl, GraphType *graph, float ubfactor)
{
idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps;
idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idxtype *perm, *moved;
PQueueType parts;
NRInfoType *rinfo;
idxtype higain, oldgain;
idxtype pass, to, other;
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;
if (idxtype_abs(pwgts[0]-pwgts[1]) < (int)((ubfactor-1.0)*(pwgts[0]+pwgts[1])))
return;
if (idxtype_abs(pwgts[0]-pwgts[1]) < 3*idxsum(nvtxs, vwgt, 1)/nvtxs)
return;
to = (pwgts[0] < pwgts[1] ? 0 : 1);
other = (to+1)%2;
PQueueInit(ctrl, &parts, nvtxs, ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt));
perm = idxwspacemalloc(ctrl, nvtxs);
moved = idxset(nvtxs, -1, idxwspacemalloc(ctrl, nvtxs));
IFSET(ctrl->dbglvl, DBG_REFINE,
mprintf("Partitions: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D [B]\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(where[i] == 2);
PQueueInsert(&parts, 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 = PQueueGetMax(&parts)) == -1)
break;
moved[higain] = 1;
if (pwgts[other] - rinfo[higain].edegrees[other] < (pwgts[0]+pwgts[1])/2)
continue;
#ifdef XXX
if (pwgts[other] - rinfo[higain].edegrees[other] < pwgts[to]+vwgt[higain])
break;
#endif
ASSERT(bndptr[higain] != -1);
pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
BNDDelete(nbnd, bndind, bndptr, higain);
pwgts[to] += vwgt[higain];
where[higain] = to;
IFSET(ctrl->dbglvl, DBG_MOVEINFO,
mprintf("Moved %6D to %3D, Gain: %3D, \t[%5D %5D %5D]\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, ("%d %d %d\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)
PQueueUpdateUp(&parts, kk, oldgain, oldgain+vwgt[k]);
}
}
/* Insert the new vertex into the priority queue */
PQueueInsert(&parts, k, vwgt[k]-edegrees[other]);
}
}
if (pwgts[to] > pwgts[other])
break;
}
IFSET(ctrl->dbglvl, DBG_REFINE,
mprintf("\tBalanced sep: %6D at %4D, PWGTS: [%6D %6D], NBND: %6D\n", pwgts[2], nswaps, pwgts[0], pwgts[1], nbnd));
graph->mincut = pwgts[2];
graph->nbnd = nbnd;
PQueueFree(ctrl, &parts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs a node-based FM refinement. This is the
* one-way version
**************************************************************************/
void FM_2WayNodeRefine_OneSided(CtrlType *ctrl, GraphType *graph, float ubfactor, idxtype npasses)
{
idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idxtype *mptr, *mind, *swaps, *perm;
PQueueType parts;
NRInfoType *rinfo;
idxtype higain, oldgain, mincut, initcut, mincutorder;
idxtype pass, to, other, limit;
idxtype badmaxpwgt, mindiff, newdiff;
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;
PQueueInit(ctrl, &parts, nvtxs, ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt));
perm = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
mptr = idxwspacemalloc(ctrl, nvtxs+1);
mind = idxwspacemalloc(ctrl, nvtxs);
IFSET(ctrl->dbglvl, DBG_REFINE,
mprintf("Partitions-N1: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2])/2);
to = (pwgts[0] < pwgts[1] ? 1 : 0);
for (pass=0; pass<npasses; pass++) {
other = to;
to = (to+1)%2;
PQueueReset(&parts);
mincutorder = -1;
initcut = mincut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(where[i] == 2);
PQueueInsert(&parts, i, vwgt[i]-rinfo[i].edegrees[other]);
}
ASSERT(CheckNodeBnd(graph, nbnd));
ASSERT(CheckNodePartitionParams(graph));
limit = (ctrl->oflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300));
/******************************************************
* Get into the FM loop
*******************************************************/
mptr[0] = nmind = 0;
mindiff = idxtype_abs(pwgts[0]-pwgts[1]);
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if ((higain = PQueueGetMax(&parts)) == -1)
break;
ASSERT(bndptr[higain] != -1);
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 = idxtype_abs(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 > limit) {
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
***********************************************************/
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, ("%d %d %d\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];
/* Since the moves are one-sided this vertex has not been moved yet */
PQueueUpdateUp(&parts, kk, oldgain, oldgain+vwgt[k]);
}
}
/* Insert the new vertex into the priority queue. Safe due to one-sided moves */
PQueueInsert(&parts, k, vwgt[k]-edegrees[other]);
}
}
mptr[nswaps+1] = nmind;
IFSET(ctrl->dbglvl, DBG_MOVEINFO,
mprintf("Moved %6D to %3D, Gain: %5D [%5D] \t[%5D %5D %5D] [%3D %2D]\n",
higain, to, (vwgt[higain]-rinfo[higain].edegrees[other]), vwgt[higain], pwgts[0], pwgts[1], pwgts[2], nswaps, limit));
}
/****************************************************************
* Roll back computation
*****************************************************************/
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]; 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, DBG_REFINE,
mprintf("\tMinimum sep: %6D at %5D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
graph->mincut = mincut;
graph->nbnd = nbnd;
if (pass%2 == 1 && (mincutorder == -1 || mincut >= initcut))
break;
}
PQueueFree(ctrl, &parts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs+1);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs a node-based FM refinement
**************************************************************************/
void FM_2WayNodeRefineEqWgt(CtrlType *ctrl, GraphType *graph, idxtype npasses)
{
idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idxtype *mptr, *mind, *moved, *swaps, *perm;
PQueueType parts[2];
NRInfoType *rinfo;
idxtype higain, oldgain, mincut, initcut, mincutorder;
idxtype pass, to, other, limit;
idxtype mindiff, newdiff;
idxtype u[2], g[2];
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;
i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt);
PQueueInit(ctrl, &parts[0], nvtxs, i);
PQueueInit(ctrl, &parts[1], nvtxs, i);
moved = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
mptr = idxwspacemalloc(ctrl, nvtxs+1);
mind = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
IFSET(ctrl->dbglvl, DBG_REFINE,
mprintf("Partitions: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
for (pass=0; pass<npasses; pass++) {
idxset(nvtxs, -1, moved);
PQueueReset(&parts[0]);
PQueueReset(&parts[1]);
mincutorder = -1;
initcut = mincut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(where[i] == 2);
PQueueInsert(&parts[0], i, vwgt[i]-rinfo[i].edegrees[1]);
PQueueInsert(&parts[1], i, vwgt[i]-rinfo[i].edegrees[0]);
}
ASSERT(CheckNodeBnd(graph, nbnd));
ASSERT(CheckNodePartitionParams(graph));
limit = (ctrl->oflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300));
/******************************************************
* Get into the FM loop
*******************************************************/
mptr[0] = nmind = 0;
mindiff = idxtype_abs(pwgts[0]-pwgts[1]);
to = (pwgts[0] < pwgts[1] ? 0 : 1);
for (nswaps=0; nswaps<nvtxs; nswaps++) {
to = (pwgts[0] < pwgts[1] ? 0 : 1);
if (pwgts[0] == pwgts[1]) {
u[0] = PQueueSeeMax(&parts[0]);
u[1] = PQueueSeeMax(&parts[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));
}
}
other = (to+1)%2;
if ((higain = PQueueGetMax(&parts[to])) == -1)
break;
if (moved[higain] == -1) /* Delete if it was in the separator originally */
PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]);
ASSERT(bndptr[higain] != -1);
pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
newdiff = idxtype_abs(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 > limit) {
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))
PQueueUpdate(&parts[other], k, oldgain, oldgain-vwgt[higain]);
}
else if (where[k] == other) { /* This vertex is pulled into the separator */
ASSERTP(bndptr[k] == -1, ("%d %d %d\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))
PQueueUpdate(&parts[to], kk, oldgain, oldgain+vwgt[k]);
}
}
/* Insert the new vertex into the priority queue. Only one side! */
if (moved[k] == -1) {
PQueueInsert(&parts[to], k, vwgt[k]-edegrees[other]);
moved[k] = -(2+to);
}
}
}
mptr[nswaps+1] = nmind;
IFSET(ctrl->dbglvl, DBG_MOVEINFO,
mprintf("Moved %6D to %3D, Gain: %5D [%5D] [%4D %4D] \t[%5D %5D %5D]\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, DBG_REFINE,
mprintf("\tMinimum sep: %6D at %5D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
graph->mincut = mincut;
graph->nbnd = nbnd;
if (mincutorder == -1 || mincut >= initcut)
break;
}
PQueueFree(ctrl, &parts[0]);
PQueueFree(ctrl, &parts[1]);
idxwspacefree(ctrl, nvtxs+1);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
void FM_2WayNodeRefine_TwoSidedP(CtrlType *ctrl, GraphType *graph,
idxtype *hmarker, float ubfactor, int npasses)
{
int i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idxtype *mptr, *mind, *moved, *swaps, *perm;
PQueueType parts[2];
NRInfoType *rinfo;
int higain, oldgain, mincut, initcut, mincutorder;
int pass, to, other, limit;
int badmaxpwgt, mindiff, newdiff;
int u[2], g[2];
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;
i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt);
PQueueInit(ctrl, &parts[0], nvtxs, i);
PQueueInit(ctrl, &parts[1], nvtxs, i);
moved = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
mptr = idxwspacemalloc(ctrl, nvtxs+1);
mind = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d] Nv-Nb[%6d %6d]. ISep: %6d\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
badmaxpwgt = (int)(ubfactor*amax(pwgts[0], pwgts[1]));
for (pass=0; pass<npasses; pass++) {
idxset(nvtxs, -1, moved);
PQueueReset(&parts[0]);
PQueueReset(&parts[1]);
mincutorder = -1;
initcut = mincut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(where[i] == 2);
if (hmarker[i] == -1) {
PQueueInsert(&parts[0], i, vwgt[i]-rinfo[i].edegrees[1]);
PQueueInsert(&parts[1], i, vwgt[i]-rinfo[i].edegrees[0]);
moved[i] = -5;
}
else if (hmarker[i] != 2) {
PQueueInsert(&parts[hmarker[i]], i, vwgt[i]-rinfo[i].edegrees[(hmarker[i]+1)%2]);
moved[i] = -(10+hmarker[i]);
}
}
ASSERT(CheckNodeBnd(graph, nbnd));
ASSERT(CheckNodePartitionParams(graph));
limit = nbnd;
/******************************************************
* Get into the FM loop
*******************************************************/
mptr[0] = nmind = 0;
mindiff = abs(pwgts[0]-pwgts[1]);
to = (pwgts[0] < pwgts[1] ? 0 : 1);
for (nswaps=0; nswaps<nvtxs; nswaps++) {
u[0] = PQueueSeeMax(&parts[0]);
u[1] = PQueueSeeMax(&parts[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 = PQueueGetMax(&parts[to]);
/* Delete its matching entry in the other queue */
if (moved[higain] == -5)
PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]);
ASSERT(bndptr[higain] != -1);
pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
newdiff = abs(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 > limit) {
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] == -5 || moved[k] == -(10+other))
PQueueUpdate(&parts[other], k, oldgain, oldgain-vwgt[higain]);
}
else if (where[k] == other) { /* This vertex is pulled into the separator */
ASSERTP(bndptr[k] == -1, ("%d %d %d\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] == -5 || moved[kk] == -(10+to))
PQueueUpdate(&parts[to], kk, oldgain, oldgain+vwgt[k]);
}
}
/* Insert the new vertex into the priority queue (if it has not been moved). */
if (moved[k] == -1 && (hmarker[k] == -1 || hmarker[k] == to)) {
PQueueInsert(&parts[to], k, vwgt[k]-edegrees[other]);
moved[k] = -(10+to);
}
#ifdef FULLMOVES /* this does not work as well as the above partial one */
if (moved[k] == -1) {
if (hmarker[k] == -1) {
PQueueInsert(&parts[0], k, vwgt[k]-edegrees[1]);
PQueueInsert(&parts[1], k, vwgt[k]-edegrees[0]);
moved[k] = -5;
}
else if (hmarker[k] != 2) {
PQueueInsert(&parts[hmarker[k]], k, vwgt[k]-edegrees[(hmarker[k]+1)%2]);
moved[k] = -(10+hmarker[k]);
}
}
#endif
}
}
mptr[nswaps+1] = nmind;
IFSET(ctrl->dbglvl, DBG_MOVEINFO,
printf("Moved %6d to %3d, Gain: %5d [%5d] [%4d %4d] \t[%5d %5d %5d]\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, DBG_REFINE,
printf("\tMinimum sep: %6d at %5d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
graph->mincut = mincut;
graph->nbnd = nbnd;
if (mincutorder == -1 || mincut >= initcut)
break;
}
PQueueFree(ctrl, &parts[0]);
PQueueFree(ctrl, &parts[1]);
idxwspacefree(ctrl, nvtxs+1);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
void FM_2WayNodeRefine_OneSidedP(CtrlType *ctrl, GraphType *graph,
idxtype *hmarker, float ubfactor, int npasses)
{
int i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind, nbad, qsize;
idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
idxtype *mptr, *mind, *swaps, *perm, *inqueue;
PQueueType parts;
NRInfoType *rinfo;
int higain, oldgain, mincut, initcut, mincutorder;
int pass, from, to, limit;
int badmaxpwgt, mindiff, newdiff;
ASSERT(graph->mincut == graph->pwgts[2]);
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;
PQueueInit(ctrl, &parts, nvtxs, ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt));
perm = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
mptr = idxwspacemalloc(ctrl, nvtxs+1);
mind = idxwspacemalloc(ctrl, nvtxs);
inqueue = idxwspacemalloc(ctrl, nvtxs);
idxset(nvtxs, -1, inqueue);
badmaxpwgt = (int)(ubfactor*amax(pwgts[0], pwgts[1]));
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions-N1: [%6d %6d] Nv-Nb[%6d %6d] MaxPwgt[%6d]. ISep: %6d\n",
pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, badmaxpwgt, graph->mincut));
to = (pwgts[0] < pwgts[1] ? 1 : 0);
for (pass=0; pass<npasses; pass++) {
from = to;
to = (from+1)%2;
PQueueReset(&parts);
mincutorder = -1;
initcut = mincut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(where[i] == 2);
if (hmarker[i] == -1 || hmarker[i] == to) {
PQueueInsert(&parts, i, vwgt[i]-rinfo[i].edegrees[from]);
inqueue[i] = pass;
}
}
qsize = parts.nnodes;
ASSERT(CheckNodeBnd(graph, nbnd));
ASSERT(CheckNodePartitionParams(graph));
limit = nbnd;
/******************************************************
* Get into the FM loop
*******************************************************/
mptr[0] = nmind = nbad = 0;
mindiff = abs(pwgts[0]-pwgts[1]);
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if ((higain = PQueueGetMax(&parts)) == -1)
break;
inqueue[higain] = -1;
ASSERT(bndptr[higain] != -1);
if (pwgts[to]+vwgt[higain] > badmaxpwgt) { /* Skip this vertex */
if (nbad++ > limit)
break;
else {
nswaps--;
continue;
}
}
pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[from]);
newdiff = abs(pwgts[to]+vwgt[higain] - (pwgts[from]-rinfo[higain].edegrees[from]));
if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) {
mincut = pwgts[2];
mincutorder = nswaps;
mindiff = newdiff;
nbad = 0;
}
else {
if (nbad++ > limit) {
pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[from]);
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
***********************************************************/
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] == from) { /* This vertex is pulled into the separator */
ASSERTP(bndptr[k] == -1, ("%d %d %d\n", k, bndptr[k], where[k]));
BNDInsert(nbnd, bndind, bndptr, k);
mind[nmind++] = k; /* Keep track for rollback */
where[k] = 2;
pwgts[from] -= 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[from];
rinfo[kk].edegrees[from] -= vwgt[k];
/* Update the gain of this node if it was skipped */
if (inqueue[kk] == pass)
PQueueUpdateUp(&parts, kk, oldgain, oldgain+vwgt[k]);
}
}
/* Insert the new vertex into the priority queue. Safe due to one-sided moves */
if (hmarker[k] == -1 || hmarker[k] == to) {
PQueueInsert(&parts, k, vwgt[k]-edegrees[from]);
inqueue[k] = pass;
}
}
}
mptr[nswaps+1] = nmind;
IFSET(ctrl->dbglvl, DBG_MOVEINFO,
printf("Moved %6d to %3d, Gain: %5d [%5d] \t[%5d %5d %5d] [%3d %2d]\n",
higain, to, (vwgt[higain]-rinfo[higain].edegrees[from]), vwgt[higain], pwgts[0], pwgts[1], pwgts[2], nswaps, limit));
}
/****************************************************************
* Roll back computation
*****************************************************************/
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] = from;
INC_DEC(pwgts[from], 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[from] += vwgt[k];
}
}
}
ASSERT(mincut == pwgts[2]);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\tMinimum sep: %6d at %5d, PWGTS: [%6d %6d], NBND: %6d, QSIZE: %6d\n",
mincut, mincutorder, pwgts[0], pwgts[1], nbnd, qsize));
graph->mincut = mincut;
graph->nbnd = nbnd;
if (pass%2 == 1 && (mincutorder == -1 || mincut >= initcut))
break;
}
PQueueFree(ctrl, &parts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs+1);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
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;
}
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 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;
}