/*************************************************************************
* This file randomly permutes the contents of an array.
* flag == 0, don't initialize perm
* flag == 1, set p[i] = i
**************************************************************************/
void FastRandomPermute(int n, idxtype *p, int flag)
{
int i, u, v;
idxtype tmp;
/* this is for very small arrays */
if (n < 25) {
RandomPermute(n, p, flag);
return;
}
if (flag == 1) {
for (i=0; i<n; i++)
p[i] = i;
}
for (i=0; i<n; i+=8) {
v = RandomInRange(n-4);
u = RandomInRange(n-4);
SWAP(p[v], p[u], tmp);
SWAP(p[v+1], p[u+1], tmp);
SWAP(p[v+2], p[u+2], tmp);
SWAP(p[v+3], p[u+3], tmp);
}
}
/*************************************************************************
* This function finds a matching using the HEM heuristic
**************************************************************************/
void Match_HEM(CtrlType *ctrl, GraphType *graph)
{
int i, ii, j, k, nvtxs, cnvtxs, maxidx, dim;
idxtype *xadj, *vwgt, *adjncy;
idxtype *match, *cmap, *perm, *tperm;
realtype curwgt, maxwgt;
realtype *vvol, *vsurf, *adjwgt, *adjwgtsum;
dim = ctrl->dim;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
vvol = graph->vvol;
vsurf = graph->vsurf;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
adjwgtsum = graph->adjwgtsum;
cmap = graph->cmap = idxsmalloc(nvtxs, -1, "cmap");
match = idxsmalloc(nvtxs, -1, "match");
perm = idxmalloc(nvtxs, "perm");
tperm = idxmalloc(nvtxs, "tperm");
RandomPermute(nvtxs, tperm, 1);
BucketSortKeysInc(nvtxs, vwgt[iamax(nvtxs, vwgt)], vwgt, tperm, perm);
/* RandomPermute(nvtxs, perm, 1); */
cnvtxs = 0;
/* Compute a heavy-edge style matching giving preferance to small vertices */
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) {
maxidx = i;
maxwgt = 0.0;
/* Find a heavy-edge matching, subject to maxvwgt constraints */
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = adjncy[j];
curwgt = 1.0/ARATIO2(dim, vsurf[i]+vsurf[k]+adjwgtsum[i]+adjwgtsum[k]-
2.0*adjwgt[j], vvol[i]+vvol[k]);
if (match[k] == UNMATCHED && vwgt[i]+vwgt[k] <= ctrl->maxsize &&
curwgt > maxwgt) {
maxwgt = curwgt;
maxidx = k;
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
CreateCoarseGraph(graph, cnvtxs, match, perm);
IMfree((void**)&tperm, &perm, &match, LTERM);
}
int main(int argc, char **argv) {
long *X, *Tmp, n, i;
double *D;
printf("Test RandomPermute: ");
n=1000 ;
X = (long *) malloc(n* sizeof(long)) ;
Tmp = (long *) malloc(n* sizeof(long)) ;
D = (double *) malloc(n* sizeof(double)) ;
if ( X == NULL || Tmp == NULL || D == NULL){
printf("Error\n") ;
exit(1);
}
for (i=0; i<n; i++){
X[i] = i ;
D[i] = i;
}
#ifdef INFO2
printf("RAND_MAX = %ld ", (long)(RAND_MAX) );
#endif
/* Permute randomly */
RandomPermute(X,NULL,D,NULL,0,n-1);
/* Check result values and corresponding indices */
for (i=0; i<n; i++){
if (X[i] != (long)(D[i]+0.5) || X[i] < 0 || X[i] >= n){
/* round to nearest integer */
printf("Error\n") ;
exit(1);
}
}
/* Check whether X is a permutation of 0..n-1.
Use Tmp as a temporary array */
for (i=0; i<n; i++)
Tmp[i] = -1;
for (i=0; i<n; i++){
Tmp[X[i]]= X[i];
}
for (i=0; i<n; i++){
if (Tmp[i] != i){
printf("Error\n") ;
exit(1);
}
}
printf("OK\n") ;
exit(0);
} /* end main */
/*************************************************************************
* This function finds a matching using the HEM heuristic
**************************************************************************/
void MCMatch_HEM(CtrlType *ctrl, GraphType *graph)
{
int i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *match, *cmap, *perm;
float *nvwgt;
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;
cmap = graph->cmap;
match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
perm = idxwspacemalloc(ctrl, nvtxs);
RandomPermute(nvtxs, perm, 1);
cnvtxs = 0;
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
maxidx = i;
maxwgt = 0;
/* Find a heavy-edge matching, subject to maxvwgt constraints */
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = adjncy[j];
if (match[k] == UNMATCHED && maxwgt <= adjwgt[j] &&
AreAllVwgtsBelowFast(ncon, nvwgt+i*ncon, nvwgt+k*ncon, ctrl->nmaxvwgt)) {
maxwgt = adjwgt[j];
maxidx = adjncy[j];
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function finds a matching using the HEM heuristic
**************************************************************************/
void Match_RM(CtrlType *ctrl, GraphType *graph)
{
int i, ii, j, nvtxs, cnvtxs, maxidx;
idxtype *xadj, *vwgt, *adjncy, *adjwgt;
idxtype *match, *cmap, *perm;
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
cmap = graph->cmap;
match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
perm = idxwspacemalloc(ctrl, nvtxs);
RandomPermute(nvtxs, perm, 1);
cnvtxs = 0;
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
maxidx = i;
/* Find a random matching, subject to maxvwgt constraints */
for (j=xadj[i]; j<xadj[i+1]; j++) {
if (match[adjncy[j]] == UNMATCHED && vwgt[i]+vwgt[adjncy[j]] <= ctrl->maxvwgt) {
maxidx = adjncy[j];
break;
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function generates random initialization
**************************************************************************/
void RandomInit(int n, int k, idxtype *label)
{
int i, chunksize, j;
idxtype tmp;
idxtype *p= idxmalloc(n, "Util: RandomInit\n");
RandomPermute(n, p, 1);
chunksize = n / k +1;
j=0;
for (i=0; i<n; i++){
label[p[i]] = j;
if ((i+1)% chunksize ==0)
j++;
}
free (p);
}
/*************************************************************************
* This function finds a matching using the HEM heuristic
**************************************************************************/
void Match_RM(CtrlType *ctrl, GraphType *graph)
{
int i, ii, j, k, nvtxs, cnvtxs, maxidx;
idxtype *xadj, *vwgt, *adjncy;
idxtype *match, *cmap, *perm;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
cmap = graph->cmap = idxsmalloc(nvtxs, -1, "graph->cmap");
match = idxsmalloc(nvtxs, -1, "match");
perm = idxmalloc(nvtxs, "perm");
RandomPermute(nvtxs, perm, 1);
cnvtxs = 0;
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) {
maxidx = i;
/* Find a random matching, subject to maxvwgt constraints */
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = adjncy[j];
if (match[k] == UNMATCHED && vwgt[i]+vwgt[k] <= ctrl->maxsize) {
maxidx = k;
break;
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
CreateCoarseGraph(graph, cnvtxs, match, perm);
IMfree((void**)&match, &perm, LTERM);
}
/*************************************************************************
* This function finds a matching using the HEM heuristic
**************************************************************************/
void EstimateCFraction(int nvtxs, idxtype *xadj, idxtype *adjncy, floattype *vfraction, floattype *efraction)
{
int i, ii, j, cnvtxs, cnedges, maxidx;
idxtype *match, *cmap, *perm;
cmap = idxmalloc(nvtxs, "cmap");
match = idxsmalloc(nvtxs, UNMATCHED, "match");
perm = idxmalloc(nvtxs, "perm");
RandomPermute(nvtxs, perm, 1);
cnvtxs = 0;
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
maxidx = i;
/* Find a random matching, subject to maxvwgt constraints */
for (j=xadj[i]; j<xadj[i+1]; j++) {
if (match[adjncy[j]] == UNMATCHED) {
maxidx = adjncy[j];
break;
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
cnedges = ComputeCoarseGraphSize(nvtxs, xadj, adjncy, cnvtxs, cmap, match, perm);
*vfraction = (1.0*cnvtxs)/(1.0*nvtxs);
*efraction = (1.0*cnedges)/(1.0*xadj[nvtxs]);
GKfree(&cmap, &match, &perm, LTERM);
}
/*************************************************************************
* This function performs k-way refinement
**************************************************************************/
void MCRandom_KWayEdgeRefineHorizontal(CtrlType *ctrl, GraphType *graph, int nparts,
float *orgubvec, int npasses)
{
int i, ii, iii, j, /*jj,*/ k, /*l,*/ pass, nvtxs, ncon, nmoves, nbnd, myndegrees, same;
int from, me, to, oldcut, gain;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *perm, *bndptr, *bndind;
EDegreeType *myedegrees;
RInfoType *myrinfo;
float *npwgts, *nvwgt, *minwgt, *maxwgt, maxlb, minlb, ubvec[MAXNCON], tvec[MAXNCON];
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
bndptr = graph->bndptr;
bndind = graph->bndind;
where = graph->where;
npwgts = graph->npwgts;
/* Setup the weight intervals of the various subdomains */
minwgt = fwspacemalloc(ctrl, nparts*ncon);
maxwgt = fwspacemalloc(ctrl, nparts*ncon);
/* See if the orgubvec consists of identical constraints */
maxlb = minlb = orgubvec[0];
for (i=1; i<ncon; i++) {
minlb = (orgubvec[i] < minlb ? orgubvec[i] : minlb);
maxlb = (orgubvec[i] > maxlb ? orgubvec[i] : maxlb);
}
same = (fabs(maxlb-minlb) < .01 ? 1 : 0);
/* Let's not get very optimistic. Let Balancing do the work */
ComputeHKWayLoadImbalance(ncon, nparts, npwgts, ubvec);
for (i=0; i<ncon; i++)
ubvec[i] = amax(ubvec[i], orgubvec[i]);
if (!same) {
for (i=0; i<nparts; i++) {
for (j=0; j<ncon; j++) {
maxwgt[i*ncon+j] = ubvec[j]/nparts;
minwgt[i*ncon+j] = 1.0/(ubvec[j]*nparts);
}
}
}
else {
maxlb = ubvec[0];
for (i=1; i<ncon; i++)
maxlb = (ubvec[i] > maxlb ? ubvec[i] : maxlb);
for (i=0; i<nparts; i++) {
for (j=0; j<ncon; j++) {
maxwgt[i*ncon+j] = maxlb/nparts;
minwgt[i*ncon+j] = 1.0/(maxlb*nparts);
}
}
}
perm = idxwspacemalloc(ctrl, nvtxs);
if (ctrl->dbglvl&DBG_REFINE) {
printf("Partitions: [%5.4f %5.4f], Nv-Nb[%6d %6d]. Cut: %6d, LB: ",
npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)],
graph->nvtxs, graph->nbnd, graph->mincut);
ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
for (i=0; i<ncon; i++)
printf("%.3f ", tvec[i]);
printf("\n");
}
for (pass=0; pass<npasses; pass++) {
ASSERT(ComputeCut(graph, where) == graph->mincut);
oldcut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (nmoves=iii=0; iii<graph->nbnd; iii++) {
ii = perm[iii];
if (ii >= nbnd)
continue;
i = bndind[ii];
myrinfo = graph->rinfo+i;
if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */
from = where[i];
nvwgt = graph->nvwgt+i*ncon;
if (myrinfo->id > 0 && AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, -1.0, nvwgt, minwgt+from*ncon))
continue; /* This cannot be moved! */
myedegrees = myrinfo->edegrees;
myndegrees = myrinfo->ndegrees;
for (k=0; k<myndegrees; k++) {
to = myedegrees[k].pid;
gain = myedegrees[k].ed - myrinfo->id;
if (gain >= 0 &&
(AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon) ||
IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec)))
break;
}
if (k == myndegrees)
continue; /* break out if you did not find a candidate */
for (j=k+1; j<myndegrees; j++) {
to = myedegrees[j].pid;
if ((myedegrees[j].ed > myedegrees[k].ed &&
(AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon) ||
IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec))) ||
(myedegrees[j].ed == myedegrees[k].ed &&
IsHBalanceBetterTT(ncon, nparts, npwgts+myedegrees[k].pid*ncon, npwgts+to*ncon, nvwgt, ubvec)))
k = j;
}
to = myedegrees[k].pid;
if (myedegrees[k].ed-myrinfo->id == 0
&& !IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec)
&& AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, npwgts+from*ncon, maxwgt+from*ncon))
continue;
/*=====================================================================
* If we got here, we can now move the vertex from 'from' to 'to'
*======================================================================*/
graph->mincut -= myedegrees[k].ed-myrinfo->id;
IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
/* Update where, weight, and ID/ED information of the vertex you moved */
saxpy(ncon, 1.0, nvwgt, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt, 1, npwgts+from*ncon, 1);
where[i] = to;
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed-myrinfo->id < 0)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
ASSERT(CheckRInfo(myrinfo));
}
nmoves++;
}
}
graph->nbnd = nbnd;
if (ctrl->dbglvl&DBG_REFINE) {
printf("\t [%5.4f %5.4f], Nb: %6d, Nmoves: %5d, Cut: %6d, LB: ",
npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)],
nbnd, nmoves, graph->mincut);
ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
for (i=0; i<ncon; i++)
printf("%.3f ", tvec[i]);
printf("\n");
}
if (graph->mincut == oldcut)
break;
}
fwspacefree(ctrl, ncon*nparts);
fwspacefree(ctrl, ncon*nparts);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function balances two partitions by moving the highest gain
* (including negative gain) vertices to the other domain.
* It is used only when tha unbalance is due to non contigous
* subdomains. That is, the are no boundary vertices.
* It moves vertices from the domain that is overweight to the one that
* is underweight.
**************************************************************************/
void MocInit2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts)
{
int i, ii, j, k, l, kwgt, nvtxs, nbnd, ncon, nswaps, from, to, pass, me, cnum, tmp;
idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
idxtype *perm, *qnum;
float *nvwgt, *npwgts;
PQueueType parts[MAXNCON][2];
int higain, oldgain, mincut;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
adjncy = graph->adjncy;
nvwgt = graph->nvwgt;
adjwgt = graph->adjwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
npwgts = graph->npwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
perm = idxwspacemalloc(ctrl, nvtxs);
qnum = idxwspacemalloc(ctrl, nvtxs);
/* This is called for initial partitioning so we know from where to pick nodes */
from = 1;
to = (from+1)%2;
if (ctrl->dbglvl&DBG_REFINE) {
printf("Parts: [");
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f [B]\n", tpwgts[0], tpwgts[1],
graph->nvtxs, graph->nbnd, graph->mincut,
Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
}
for (i=0; i<ncon; i++) {
PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
}
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
ASSERT(CheckGraph(graph));
/* Compute the queues in which each vertex will be assigned to */
for (i=0; i<nvtxs; i++)
qnum[i] = samax(ncon, nvwgt+i*ncon);
/* Insert the nodes of the proper partition in the appropriate priority queue */
RandomPermute(nvtxs, perm, 1);
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (where[i] == from) {
if (ed[i] > 0)
PQueueInsert(&parts[qnum[i]][0], i, ed[i]-id[i]);
else
PQueueInsert(&parts[qnum[i]][1], i, ed[i]-id[i]);
}
}
mincut = graph->mincut;
nbnd = graph->nbnd;
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if (AreAnyVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, tpwgts[from]))
break;
if ((cnum = SelectQueueOneWay(ncon, npwgts, tpwgts, from, parts)) == -1)
break;
if ((higain = PQueueGetMax(&parts[cnum][0])) == -1)
higain = PQueueGetMax(&parts[cnum][1]);
mincut -= (ed[higain]-id[higain]);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
where[higain] = to;
if (ctrl->dbglvl&DBG_MOVEINFO) {
printf("Moved %6d from %d(%d). [%5d] %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], mincut);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf(", LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
if (ed[higain] == 0 && id[higain] > 0)
printf("\t Pulled from the interior!\n");
}
/**************************************************************
* Update the id[i]/ed[i] values of the affected nodes
***************************************************************/
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
oldgain = ed[k]-id[k];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
/* Update the queue position */
if (where[k] == from) {
if (ed[k] > 0 && bndptr[k] == -1) { /* It moves in boundary */
PQueueDelete(&parts[qnum[k]][1], k, oldgain);
PQueueInsert(&parts[qnum[k]][0], k, ed[k]-id[k]);
}
else { /* It must be in the boundary already */
if (bndptr[k] == -1)
printf("What you thought was wrong!\n");
PQueueUpdate(&parts[qnum[k]][0], k, oldgain, ed[k]-id[k]);
}
}
/* Update its boundary information */
if (ed[k] == 0 && bndptr[k] != -1)
BNDDelete(nbnd, bndind, bndptr, k);
else if (ed[k] > 0 && bndptr[k] == -1)
BNDInsert(nbnd, bndind, bndptr, k);
}
ASSERTP(ComputeCut(graph, where) == mincut, ("%d != %d\n", ComputeCut(graph, where), mincut));
}
if (ctrl->dbglvl&DBG_REFINE) {
printf("\tMincut: %6d, NBND: %6d, NPwgts: ", mincut, nbnd);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf(", LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
}
graph->mincut = mincut;
graph->nbnd = nbnd;
for (i=0; i<ncon; i++) {
PQueueFree(ctrl, &parts[i][0]);
PQueueFree(ctrl, &parts[i][1]);
}
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs an edge-based FM refinement
**************************************************************************/
void MocGeneral2WayBalance2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec)
{
int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, limit, tmp, cnum;
idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
idxtype *moved, *swaps, *perm, *qnum;
float *nvwgt, *npwgts, origbal[MAXNCON], minbal[MAXNCON], newbal[MAXNCON];
PQueueType parts[MAXNCON][2];
int higain, oldgain, mincut, newcut, mincutorder;
float *maxwgt, *minwgt, tvec[MAXNCON];
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
nvwgt = graph->nvwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
npwgts = graph->npwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
moved = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
qnum = idxwspacemalloc(ctrl, nvtxs);
limit = amin(amax(0.01*nvtxs, 15), 100);
/* Setup the weight intervals of the two subdomains */
minwgt = fwspacemalloc(ctrl, 2*ncon);
maxwgt = fwspacemalloc(ctrl, 2*ncon);
for (i=0; i<2; i++) {
for (j=0; j<ncon; j++) {
maxwgt[i*ncon+j] = tpwgts[i]*ubvec[j];
minwgt[i*ncon+j] = tpwgts[i]*(1.0/ubvec[j]);
}
}
/* Initialize the queues */
for (i=0; i<ncon; i++) {
PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
}
for (i=0; i<nvtxs; i++)
qnum[i] = samax(ncon, nvwgt+i*ncon);
Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, origbal);
for (i=0; i<ncon; i++)
minbal[i] = origbal[i];
newcut = mincut = graph->mincut;
mincutorder = -1;
if (ctrl->dbglvl&DBG_REFINE) {
printf("Parts: [");
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: ", tpwgts[0], tpwgts[1],
graph->nvtxs, graph->nbnd, graph->mincut);
for (i=0; i<ncon; i++)
printf("%.3f ", origbal[i]);
printf("[B]\n");
}
idxset(nvtxs, -1, moved);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert all nodes in the priority queues */
nbnd = graph->nbnd;
RandomPermute(nvtxs, perm, 1);
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
}
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if (AreAllBelow(ncon, minbal, ubvec))
break;
SelectQueue3(ncon, npwgts, tpwgts, &from, &cnum, parts, maxwgt);
to = (from+1)%2;
if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
break;
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
newcut -= (ed[higain]-id[higain]);
Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, newbal);
if (IsBetter2wayBalance(ncon, newbal, minbal, ubvec) ||
(IsBetter2wayBalance(ncon, newbal, origbal, ubvec) && newcut < mincut)) {
mincut = newcut;
for (i=0; i<ncon; i++)
minbal[i] = newbal[i];
mincutorder = nswaps;
}
else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
newcut += (ed[higain]-id[higain]);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
break;
}
where[higain] = to;
moved[higain] = nswaps;
swaps[nswaps] = higain;
if (ctrl->dbglvl&DBG_MOVEINFO) {
printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
for (i=0; i<ncon; i++)
printf("(%.3f, %.3f) ", npwgts[i], npwgts[ncon+i]);
Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, tvec);
printf(", LB: ");
for (i=0; i<ncon; i++)
printf("%.3f ", tvec[i]);
if (mincutorder == nswaps)
printf(" *\n");
else
printf("\n");
}
/**************************************************************
* Update the id[i]/ed[i] values of the affected nodes
***************************************************************/
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
oldgain = ed[k]-id[k];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
/* Update the queue position */
if (moved[k] == -1)
PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, ed[k]-id[k]);
/* Update its boundary information */
if (ed[k] == 0 && bndptr[k] != -1)
BNDDelete(nbnd, bndind, bndptr, k);
else if (ed[k] > 0 && bndptr[k] == -1)
BNDInsert(nbnd, bndind, bndptr, 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);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((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);
}
}
if (ctrl->dbglvl&DBG_REFINE) {
printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
for (i=0; i<ncon; i++)
printf("(%.3f, %.3f) ", npwgts[i], npwgts[ncon+i]);
printf("], LB: ");
Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, tvec);
for (i=0; i<ncon; i++)
printf("%.3f ", tvec[i]);
printf("\n");
}
graph->mincut = mincut;
graph->nbnd = nbnd;
for (i=0; i<ncon; i++) {
PQueueFree(ctrl, &parts[i][0]);
PQueueFree(ctrl, &parts[i][1]);
}
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
fwspacefree(ctrl, 2*ncon);
fwspacefree(ctrl, 2*ncon);
}
/*************************************************************************
* 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 takes a graph and produces a bisection by using a region
* growing algorithm. The resulting partition is returned in
* graph->where
**************************************************************************/
void MocRandomBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor)
{
int i, ii, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs, qnum;
idxtype *bestwhere, *where, *perm;
int counts[MAXNCON];
float *nvwgt;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
nvwgt = graph->nvwgt;
MocAllocate2WayPartitionMemory(ctrl, graph);
where = graph->where;
bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
bestcut = idxsum(graph->nedges, graph->adjwgt);
perm = idxmalloc(nvtxs, "BisectGraph: perm");
for (; nbfs>0; nbfs--) {
for (i=0; i<ncon; i++)
counts[i] = 0;
RandomPermute(nvtxs, perm, 1);
/* Partition by spliting the queues randomly */
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
qnum = samax(ncon, nvwgt+i*ncon);
where[i] = counts[qnum];
counts[qnum] = (counts[qnum]+1)%2;
}
MocCompute2WayPartitionParams(ctrl, graph);
MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 6);
MocBalance2Way(ctrl, graph, tpwgts, 1.02);
MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 6);
MocBalance2Way(ctrl, graph, tpwgts, 1.02);
MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 6);
/*
printf("Edgecut: %6d, NPwgts: [", graph->mincut);
for (i=0; i<graph->ncon; i++)
printf("(%.3f %.3f) ", graph->npwgts[i], graph->npwgts[graph->ncon+i]);
printf("]\n");
*/
if (bestcut > graph->mincut) {
bestcut = graph->mincut;
idxcopy(nvtxs, where, bestwhere);
if (bestcut == 0)
break;
}
}
graph->mincut = bestcut;
idxcopy(nvtxs, bestwhere, where);
GKfree((void**)&bestwhere, &perm, LTERM);
}
/*************************************************************************
* 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);
}
/*************************************************************************
* 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 k-way refinement
**************************************************************************/
void MCGreedy_KWayEdgeBalanceHorizontal(CtrlType *ctrl, GraphType *graph, int nparts,
float *ubvec, int npasses)
{
int i, ii, /*iii,*/ j, /*jj,*/ k, /*l,*/ pass, nvtxs, ncon, nbnd, myndegrees, oldgain, gain, nmoves;
int from, me, to, oldcut;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *perm, *bndptr, *bndind, *moved;
EDegreeType *myedegrees;
RInfoType *myrinfo;
PQueueType queue;
float *npwgts, *nvwgt, *minwgt, *maxwgt, tvec[MAXNCON];
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
bndind = graph->bndind;
bndptr = graph->bndptr;
where = graph->where;
npwgts = graph->npwgts;
/* Setup the weight intervals of the various subdomains */
minwgt = fwspacemalloc(ctrl, ncon*nparts);
maxwgt = fwspacemalloc(ctrl, ncon*nparts);
for (i=0; i<nparts; i++) {
for (j=0; j<ncon; j++) {
maxwgt[i*ncon+j] = ubvec[j]/nparts;
minwgt[i*ncon+j] = 1.0/(ubvec[j]*nparts);
}
}
perm = idxwspacemalloc(ctrl, nvtxs);
moved = idxwspacemalloc(ctrl, nvtxs);
PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
if (ctrl->dbglvl&DBG_REFINE) {
printf("Partitions: [%5.4f %5.4f], Nv-Nb[%6d %6d]. Cut: %6d, LB: ",
npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)],
graph->nvtxs, graph->nbnd, graph->mincut);
ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
for (i=0; i<ncon; i++)
printf("%.3f ", tvec[i]);
printf("[B]\n");
}
for (pass=0; pass<npasses; pass++) {
ASSERT(ComputeCut(graph, where) == graph->mincut);
/* Check to see if things are out of balance, given the tolerance */
if (MocIsHBalanced(ncon, nparts, npwgts, ubvec))
break;
PQueueReset(&queue);
idxset(nvtxs, -1, moved);
oldcut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
moved[i] = 2;
}
nmoves = 0;
for (;;) {
if ((i = PQueueGetMax(&queue)) == -1)
break;
moved[i] = 1;
myrinfo = graph->rinfo+i;
from = where[i];
nvwgt = graph->nvwgt+i*ncon;
if (AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, -1.0, nvwgt, minwgt+from*ncon))
continue; /* This cannot be moved! */
myedegrees = myrinfo->edegrees;
myndegrees = myrinfo->ndegrees;
for (k=0; k<myndegrees; k++) {
to = myedegrees[k].pid;
if (IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec))
break;
}
if (k == myndegrees)
continue; /* break out if you did not find a candidate */
for (j=k+1; j<myndegrees; j++) {
to = myedegrees[j].pid;
if (IsHBalanceBetterTT(ncon, nparts, npwgts+myedegrees[k].pid*ncon, npwgts+to*ncon, nvwgt, ubvec))
k = j;
}
to = myedegrees[k].pid;
j = 0;
if (!AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, maxwgt+from*ncon))
j++;
if (myedegrees[k].ed-myrinfo->id >= 0)
j++;
if (!AreAllHVwgtsAbove(ncon, 1.0, npwgts+to*ncon, 0.0, nvwgt, minwgt+to*ncon) &&
AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon))
j++;
if (j == 0)
continue;
/* DELETE
if (myedegrees[k].ed-myrinfo->id < 0 &&
AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, maxwgt+from*ncon) &&
AreAllHVwgtsAbove(ncon, 1.0, npwgts+to*ncon, 0.0, nvwgt, minwgt+to*ncon) &&
AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon))
continue;
*/
/*=====================================================================
* If we got here, we can now move the vertex from 'from' to 'to'
*======================================================================*/
graph->mincut -= myedegrees[k].ed-myrinfo->id;
IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
/* Update where, weight, and ID/ED information of the vertex you moved */
saxpy(ncon, 1.0, nvwgt, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt, 1, npwgts+from*ncon, 1);
where[i] = to;
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed == 0)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
oldgain = (myrinfo->ed-myrinfo->id);
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed > 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed == 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
/* Update the queue */
if (me == to || me == from) {
gain = myrinfo->ed-myrinfo->id;
if (moved[ii] == 2) {
if (myrinfo->ed > 0)
PQueueUpdate(&queue, ii, oldgain, gain);
else {
PQueueDelete(&queue, ii, oldgain);
moved[ii] = -1;
}
}
else if (moved[ii] == -1 && myrinfo->ed > 0) {
PQueueInsert(&queue, ii, gain);
moved[ii] = 2;
}
}
ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
ASSERT(CheckRInfo(myrinfo));
}
nmoves++;
}
graph->nbnd = nbnd;
if (ctrl->dbglvl&DBG_REFINE) {
printf("\t [%5.4f %5.4f], Nb: %6d, Nmoves: %5d, Cut: %6d, LB: ",
npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)],
nbnd, nmoves, graph->mincut);
ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
for (i=0; i<ncon; i++)
printf("%.3f ", tvec[i]);
printf("\n");
}
if (nmoves == 0)
break;
}
PQueueFree(ctrl, &queue);
fwspacefree(ctrl, ncon*nparts);
fwspacefree(ctrl, ncon*nparts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function balances two partitions by moving boundary nodes
* from the domain that is overweight to the one that is underweight.
**************************************************************************/
void Bnd2WayBalance(CtrlType *ctrl, GraphType *graph, int *tpwgts)
{
int i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, tmp;
idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts;
idxtype *moved, *perm;
PQueueType parts;
int higain, oldgain, mincut, mindiff;
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 = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
/* Determine from which domain you will be moving data */
mindiff = abs(tpwgts[0]-pwgts[0]);
from = (pwgts[0] < tpwgts[0] ? 1 : 0);
to = (from+1)%2;
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d] T[%6d %6d], Nv-Nb[%6d %6d]. ICut: %6d [B]\n",
pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
tmp = graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)];
PQueueInit(ctrl, &parts, nvtxs, tmp);
idxset(nvtxs, -1, moved);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert the boundary nodes of the proper partition whose size is OK in the priority queue */
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = perm[ii];
ASSERT(ed[bndind[i]] > 0 || id[bndind[i]] == 0);
ASSERT(bndptr[bndind[i]] != -1);
if (where[bndind[i]] == from && vwgt[bndind[i]] <= mindiff)
PQueueInsert(&parts, bndind[i], ed[bndind[i]]-id[bndind[i]]);
}
mincut = graph->mincut;
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if ((higain = PQueueGetMax(&parts)) == -1)
break;
ASSERT(bndptr[higain] != -1);
if (pwgts[to]+vwgt[higain] > tpwgts[to])
break;
mincut -= (ed[higain]-id[higain]);
INC_DEC(pwgts[to], pwgts[from], vwgt[higain]);
where[higain] = to;
moved[higain] = nswaps;
IFSET(ctrl->dbglvl, DBG_MOVEINFO,
printf("Moved %6d from %d. [%3d %3d] %5d [%4d %4d]\n", higain, from, ed[higain]-id[higain], vwgt[higain], mincut, 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];
oldgain = ed[k]-id[k];
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 && where[k] == from && vwgt[k] <= mindiff) /* Remove it if in the queues */
PQueueDelete(&parts, k, oldgain);
}
else { /* If it has not been moved, update its position in the queue */
if (moved[k] == -1 && where[k] == from && vwgt[k] <= mindiff)
PQueueUpdate(&parts, k, oldgain, 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 && where[k] == from && vwgt[k] <= mindiff)
PQueueInsert(&parts, k, ed[k]-id[k]);
}
}
}
}
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\tMinimum cut: %6d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, pwgts[0], pwgts[1], nbnd));
graph->mincut = mincut;
graph->nbnd = nbnd;
PQueueFree(ctrl, &parts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function finds a matching using the HEM heuristic
**************************************************************************/
void MCMatch_SBHEM(CtrlType *ctrl, GraphType *graph, int norm)
{
int i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt, avgdegree;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *match, *cmap, *degrees, *perm, *tperm;
float *nvwgt, vbal;
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;
cmap = graph->cmap;
match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
perm = idxwspacemalloc(ctrl, nvtxs);
tperm = idxwspacemalloc(ctrl, nvtxs);
degrees = idxwspacemalloc(ctrl, nvtxs);
RandomPermute(nvtxs, tperm, 1);
avgdegree = (int)(0.7*(xadj[nvtxs]/nvtxs));
for (i=0; i<nvtxs; i++)
degrees[i] = (xadj[i+1]-xadj[i] > avgdegree ? avgdegree : xadj[i+1]-xadj[i]);
BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm);
cnvtxs = 0;
/* Take care any islands. Islands are matched with non-islands due to coarsening */
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
if (xadj[i] < xadj[i+1])
break;
maxidx = i;
for (j=nvtxs-1; j>ii; j--) {
k = perm[j];
if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) {
maxidx = k;
break;
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
/* Continue with normal matching */
for (; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
maxidx = i;
maxwgt = -1;
vbal = 0.0;
/* Find a heavy-edge matching, subject to maxvwgt constraints */
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = adjncy[j];
if (match[k] == UNMATCHED && AreAllVwgtsBelowFast(ncon, nvwgt+i*ncon, nvwgt+k*ncon, ctrl->nmaxvwgt)) {
if (maxidx != i)
vbal = BetterVBalance(ncon, norm, nvwgt+i*ncon, nvwgt+maxidx*ncon, nvwgt+k*ncon);
if (vbal > 0 || (vbal > -.01 && maxwgt < adjwgt[j])) {
maxwgt = adjwgt[j];
maxidx = k;
}
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
idxwspacefree(ctrl, nvtxs); /* degrees */
idxwspacefree(ctrl, nvtxs); /* tperm */
CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs k-way refinement
**************************************************************************/
void Random_KWayEdgeRefineMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses, int ffactor)
{
int i, ii, iii, j, jj, k, l, pass, nvtxs, nmoves, nbnd, tvwgt, myndegrees;
int from, me, to, oldcut, vwgt, gain;
int maxndoms, nadd;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts;
idxtype *phtable, *pmat, *pmatptr, *ndoms;
EDegreeType *myedegrees;
RInfoType *myrinfo;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
bndptr = graph->bndptr;
bndind = graph->bndind;
where = graph->where;
pwgts = graph->pwgts;
pmat = ctrl->wspace.pmat;
phtable = idxwspacemalloc(ctrl, nparts);
ndoms = idxwspacemalloc(ctrl, nparts);
ComputeSubDomainGraph(graph, nparts, pmat, ndoms);
/* Setup the weight intervals of the various subdomains */
minwgt = idxwspacemalloc(ctrl, nparts);
maxwgt = idxwspacemalloc(ctrl, nparts);
itpwgts = idxwspacemalloc(ctrl, nparts);
tvwgt = idxsum(nparts, pwgts);
ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
for (i=0; i<nparts; i++) {
itpwgts[i] = tpwgts[i]*tvwgt;
maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
}
perm = idxwspacemalloc(ctrl, nvtxs);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
graph->mincut));
for (pass=0; pass<npasses; pass++) {
ASSERT(ComputeCut(graph, where) == graph->mincut);
maxndoms = ndoms[idxamax(nparts, ndoms)];
oldcut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (nmoves=iii=0; iii<graph->nbnd; iii++) {
ii = perm[iii];
if (ii >= nbnd)
continue;
i = bndind[ii];
myrinfo = graph->rinfo+i;
if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */
from = where[i];
vwgt = graph->vwgt[i];
if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from])
continue; /* This cannot be moved! */
myedegrees = myrinfo->edegrees;
myndegrees = myrinfo->ndegrees;
/* Determine the valid domains */
for (j=0; j<myndegrees; j++) {
to = myedegrees[j].pid;
phtable[to] = 1;
pmatptr = pmat + to*nparts;
for (nadd=0, k=0; k<myndegrees; k++) {
if (k == j)
continue;
l = myedegrees[k].pid;
if (pmatptr[l] == 0) {
if (ndoms[l] > maxndoms-1) {
phtable[to] = 0;
nadd = maxndoms;
break;
}
nadd++;
}
}
if (ndoms[to]+nadd > maxndoms)
phtable[to] = 0;
if (nadd == 0)
phtable[to] = 2;
}
/* Find the first valid move */
j = myrinfo->id;
for (k=0; k<myndegrees; k++) {
to = myedegrees[k].pid;
if (!phtable[to])
continue;
gain = myedegrees[k].ed-j; /* j = myrinfo->id. Allow good nodes to move */
if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*gain && gain >= 0)
break;
}
if (k == myndegrees)
continue; /* break out if you did not find a candidate */
for (j=k+1; j<myndegrees; j++) {
to = myedegrees[j].pid;
if (!phtable[to])
continue;
if ((myedegrees[j].ed > myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) ||
(myedegrees[j].ed == myedegrees[k].ed &&
itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
k = j;
}
to = myedegrees[k].pid;
j = 0;
if (myedegrees[k].ed-myrinfo->id > 0)
j = 1;
else if (myedegrees[k].ed-myrinfo->id == 0) {
if (/*(iii&7) == 0 ||*/ phtable[myedegrees[k].pid] == 2 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
j = 1;
}
if (j == 0)
continue;
/*=====================================================================
* If we got here, we can now move the vertex from 'from' to 'to'
*======================================================================*/
graph->mincut -= myedegrees[k].ed-myrinfo->id;
IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
/* Update pmat to reflect the move of 'i' */
pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
if (pmat[from*nparts+to] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[to*nparts+from] == 0) {
ndoms[to]--;
if (ndoms[to]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
/* Update where, weight, and ID/ED information of the vertex you moved */
where[i] = to;
INC_DEC(pwgts[to], pwgts[from], vwgt);
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed-myrinfo->id < 0)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
/* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
if (me != from && me != to) {
pmat[me*nparts+from] -= adjwgt[j];
pmat[from*nparts+me] -= adjwgt[j];
if (pmat[me*nparts+from] == 0) {
ndoms[me]--;
if (ndoms[me]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[from*nparts+me] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[me*nparts+to] == 0) {
ndoms[me]++;
if (ndoms[me] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
maxndoms = ndoms[me];
}
}
if (pmat[to*nparts+me] == 0) {
ndoms[to]++;
if (ndoms[to] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
maxndoms = ndoms[to];
}
}
pmat[me*nparts+to] += adjwgt[j];
pmat[to*nparts+me] += adjwgt[j];
}
ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
ASSERT(CheckRInfo(myrinfo));
}
nmoves++;
}
}
graph->nbnd = nbnd;
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %5d, Vol: %5d, %d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves,
graph->mincut, ComputeVolume(graph, where), idxsum(nparts, ndoms)));
if (graph->mincut == oldcut)
break;
}
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs an edge-based FM refinement
**************************************************************************/
void FM_2WayEdgeRefine(CtrlType *ctrl, GraphType *graph, int *tpwgts, int npasses)
{
int i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, limit, tmp;
idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts;
idxtype *moved, *swaps, *perm;
PQueueType parts[2];
int higain, oldgain, mincut, mindiff, origdiff, initcut, newcut, mincutorder, avgvwgt;
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 = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
limit = (int) amin(amax(0.01*nvtxs, 15), 100);
avgvwgt = amin((pwgts[0]+pwgts[1])/20, 2*(pwgts[0]+pwgts[1])/nvtxs);
tmp = graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)];
PQueueInit(ctrl, &parts[0], nvtxs, tmp);
PQueueInit(ctrl, &parts[1], nvtxs, tmp);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d] T[%6d %6d], Nv-Nb[%6d %6d]. ICut: %6d\n",
pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
origdiff = abs(tpwgts[0]-pwgts[0]);
idxset(nvtxs, -1, moved);
for (pass=0; pass<npasses; pass++) { /* Do a number of passes */
PQueueReset(&parts[0]);
PQueueReset(&parts[1]);
mincutorder = -1;
newcut = mincut = initcut = graph->mincut;
mindiff = abs(tpwgts[0]-pwgts[0]);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert boundary nodes in the priority queues */
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = perm[ii];
ASSERT(ed[bndind[i]] > 0 || id[bndind[i]] == 0);
ASSERT(bndptr[bndind[i]] != -1);
PQueueInsert(&parts[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 = PQueueGetMax(&parts[from])) == -1)
break;
ASSERT(bndptr[higain] != -1);
newcut -= (ed[higain]-id[higain]);
INC_DEC(pwgts[to], pwgts[from], vwgt[higain]);
if ((newcut < mincut && abs(tpwgts[0]-pwgts[0]) <= origdiff+avgvwgt) ||
(newcut == mincut && abs(tpwgts[0]-pwgts[0]) < mindiff)) {
mincut = newcut;
mindiff = abs(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, DBG_MOVEINFO,
printf("Moved %6d from %d. [%3d %3d] %5d [%4d %4d]\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];
oldgain = ed[k]-id[k];
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 */
PQueueDelete(&parts[where[k]], k, oldgain);
}
else { /* If it has not been moved, update its position in the queue */
if (moved[k] == -1)
PQueueUpdate(&parts[where[k]], k, oldgain, 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)
PQueueInsert(&parts[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);
}
}
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\tMinimum cut: %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);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs an edge-based FM refinement
**************************************************************************/
void MocFM_2WayEdgeRefine(CtrlType *ctrl, GraphType *graph, float *tpwgts, int npasses)
{
int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum;
idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
idxtype *moved, *swaps, *perm, *qnum;
float *nvwgt, *npwgts, mindiff[MAXNCON], origbal, minbal, newbal;
PQueueType parts[MAXNCON][2];
int higain, oldgain, mincut, initcut, newcut, mincutorder;
float rtpwgts[2];
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
nvwgt = graph->nvwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
npwgts = graph->npwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
moved = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
qnum = idxwspacemalloc(ctrl, nvtxs);
limit = amin(amax(0.01*nvtxs, 25), 150);
/* Initialize the queues */
for (i=0; i<ncon; i++) {
PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
}
for (i=0; i<nvtxs; i++)
qnum[i] = samax(ncon, nvwgt+i*ncon);
origbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
rtpwgts[0] = origbal*tpwgts[0];
rtpwgts[1] = origbal*tpwgts[1];
/*
if (ctrl->dbglvl&DBG_REFINE) {
printf("Parts: [");
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f\n", tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut, origbal);
}
*/
idxset(nvtxs, -1, moved);
for (pass=0; pass<npasses; pass++) { /* Do a number of passes */
for (i=0; i<ncon; i++) {
PQueueReset(&parts[i][0]);
PQueueReset(&parts[i][1]);
}
mincutorder = -1;
newcut = mincut = initcut = graph->mincut;
for (i=0; i<ncon; i++)
mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
minbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert boundary nodes in the priority queues */
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
ASSERT(ed[i] > 0 || id[i] == 0);
ASSERT(bndptr[i] != -1);
PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
}
for (nswaps=0; nswaps<nvtxs; nswaps++) {
SelectQueue(ncon, npwgts, rtpwgts, &from, &cnum, parts);
to = (from+1)%2;
if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
break;
ASSERT(bndptr[higain] != -1);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
newcut -= (ed[higain]-id[higain]);
newbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
if ((newcut < mincut && newbal-origbal <= .00001) ||
(newcut == mincut && (newbal < minbal ||
(newbal == minbal && BetterBalance(ncon, npwgts, tpwgts, mindiff))))) {
mincut = newcut;
minbal = newbal;
mincutorder = nswaps;
for (i=0; i<ncon; i++)
mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
}
else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
newcut += (ed[higain]-id[higain]);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
break;
}
where[higain] = to;
moved[higain] = nswaps;
swaps[nswaps] = higain;
/*
if (ctrl->dbglvl&DBG_MOVEINFO) {
printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf(", %.3f LB: %.3f\n", minbal, 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];
oldgain = ed[k]-id[k];
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 */
PQueueDelete(&parts[qnum[k]][where[k]], k, oldgain);
}
else { /* If it has not been moved, update its position in the queue */
if (moved[k] == -1)
PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, 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)
PQueueInsert(&parts[qnum[k]][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);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((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);
}
}
/*
if (ctrl->dbglvl&DBG_REFINE) {
printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("], LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
}
*/
graph->mincut = mincut;
graph->nbnd = nbnd;
if (mincutorder == -1 || mincut == initcut)
break;
}
for (i=0; i<ncon; i++) {
PQueueFree(ctrl, &parts[i][0]);
PQueueFree(ctrl, &parts[i][1]);
}
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function takes a graph and a bisection and splits it into two graphs.
* It relies on the fact that adjwgt is all set to 1.
**************************************************************************/
int SplitGraphOrderCC(CtrlType *ctrl, GraphType *graph, GraphType *sgraphs, int ncmps, idxtype *cptr, idxtype *cind)
{
int i, ii, iii, j, k, l, istart, iend, mypart, nvtxs, snvtxs, snedges;
idxtype *xadj, *vwgt, *adjncy, *adjwgt, *adjwgtsum, *label, *where, *bndptr, *bndind;
idxtype *sxadj, *svwgt, *sadjncy, *sadjwgt, *sadjwgtsum, *slabel;
idxtype *rename;
idxtype *auxadjncy, *auxadjwgt;
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->SplitTmr));
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
adjwgtsum = graph->adjwgtsum;
label = graph->label;
where = graph->where;
bndptr = graph->bndptr;
bndind = graph->bndind;
ASSERT(bndptr != NULL);
/* 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;
}
rename = idxwspacemalloc(ctrl, nvtxs);
/* Go and split the graph a component at a time */
for (iii=0; iii<ncmps; iii++) {
RandomPermute(cptr[iii+1]-cptr[iii], cind+cptr[iii], 0);
snvtxs = snedges = 0;
for (j=cptr[iii]; j<cptr[iii+1]; j++) {
i = cind[j];
rename[i] = snvtxs++;
snedges += xadj[i+1]-xadj[i];
}
SetUpSplitGraph(graph, sgraphs+iii, snvtxs, snedges);
sxadj = sgraphs[iii].xadj;
svwgt = sgraphs[iii].vwgt;
sadjwgtsum = sgraphs[iii].adjwgtsum;
sadjncy = sgraphs[iii].adjncy;
sadjwgt = sgraphs[iii].adjwgt;
slabel = sgraphs[iii].label;
snvtxs = snedges = sxadj[0] = 0;
for (ii=cptr[iii]; ii<cptr[iii+1]; ii++) {
i = cind[ii];
istart = xadj[i];
iend = xadj[i+1];
if (bndptr[i] == -1) { /* This is an interior vertex */
auxadjncy = sadjncy + snedges - istart;
auxadjwgt = sadjwgt + snedges - istart;
for(j=istart; j<iend; j++)
auxadjncy[j] = adjncy[j];
snedges += iend-istart;
}
else {
l = snedges;
for (j=istart; j<iend; j++) {
k = adjncy[j];
if (where[k] != 2)
sadjncy[l++] = k;
}
snedges = l;
}
svwgt[snvtxs] = vwgt[i];
sadjwgtsum[snvtxs] = snedges-sxadj[snvtxs];
slabel[snvtxs] = label[i];
sxadj[++snvtxs] = snedges;
}
idxset(snedges, 1, sadjwgt);
for (i=0; i<snedges; i++)
sadjncy[i] = rename[sadjncy[i]];
sgraphs[iii].nvtxs = snvtxs;
sgraphs[iii].nedges = snedges;
sgraphs[iii].ncon = 1;
if (snvtxs < MMDSWITCH)
sgraphs[iii].adjwgt = NULL; /* A marker to call MMD on the driver */
}
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->SplitTmr));
idxwspacefree(ctrl, nvtxs);
return ncmps;
}
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);
}
/*************************************************************************
* This function finds a matching using the HEM heuristic
**************************************************************************/
void Match_SHEM(CtrlType *ctrl, GraphType *graph)
{
int i, ii, j, k, nvtxs, cnvtxs, maxidx, maxwgt, avgdegree;
idxtype *xadj, *vwgt, *adjncy, *adjwgt;
idxtype *match, *cmap, *degrees, *perm, *tperm;
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
cmap = graph->cmap;
match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
perm = idxwspacemalloc(ctrl, nvtxs);
tperm = idxwspacemalloc(ctrl, nvtxs);
degrees = idxwspacemalloc(ctrl, nvtxs);
RandomPermute(nvtxs, tperm, 1);
avgdegree = 0.7*(xadj[nvtxs]/nvtxs);
for (i=0; i<nvtxs; i++)
degrees[i] = (xadj[i+1]-xadj[i] > avgdegree ? avgdegree : xadj[i+1]-xadj[i]);
BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm);
cnvtxs = 0;
/* Take care any islands. Islands are matched with non-islands due to coarsening */
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
if (xadj[i] < xadj[i+1])
break;
maxidx = i;
for (j=nvtxs-1; j>ii; j--) {
k = perm[j];
if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) {
maxidx = k;
break;
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
/* Continue with normal matching */
for (; ii<nvtxs; ii++) {
i = perm[ii];
if (match[i] == UNMATCHED) { /* Unmatched */
maxidx = i;
maxwgt = 0;
/* Find a heavy-edge matching, subject to maxvwgt constraints */
for (j=xadj[i]; j<xadj[i+1]; j++) {
if (match[adjncy[j]] == UNMATCHED && maxwgt < adjwgt[j] && vwgt[i]+vwgt[adjncy[j]] <= ctrl->maxvwgt) {
maxwgt = adjwgt[j];
maxidx = adjncy[j];
}
}
cmap[i] = cmap[maxidx] = cnvtxs++;
match[i] = maxidx;
match[maxidx] = i;
}
}
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
idxwspacefree(ctrl, nvtxs); /* degrees */
idxwspacefree(ctrl, nvtxs); /* tperm */
CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function takes a graph and produces a bisection by using a region
* growing algorithm. The resulting partition is returned in
* graph->where
**************************************************************************/
void RandomBisection(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor)
{
int i, ii, j, k, nvtxs, pwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs;
idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where;
idxtype *perm, *bestwhere;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
vwgt = graph->vwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
Allocate2WayPartitionMemory(ctrl, graph);
where = graph->where;
bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
perm = idxmalloc(nvtxs, "BisectGraph: queue");
ASSERTP(tpwgts[0]+tpwgts[1] == idxsum(nvtxs, vwgt), ("%d %d\n", tpwgts[0]+tpwgts[1], idxsum(nvtxs, vwgt)));
maxpwgt[0] = ubfactor*tpwgts[0];
maxpwgt[1] = ubfactor*tpwgts[1];
minpwgt[0] = (1.0/ubfactor)*tpwgts[0];
minpwgt[1] = (1.0/ubfactor)*tpwgts[1];
nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
bestcut = idxsum(nvtxs, graph->adjwgtsum)+1; /* The +1 is for the 0 edges case */
for (; nbfs>0; nbfs--) {
RandomPermute(nvtxs, perm, 1);
idxset(nvtxs, 1, where);
pwgts[1] = tpwgts[0]+tpwgts[1];
pwgts[0] = 0;
if (nbfs != 1) {
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (pwgts[0]+vwgt[i] < maxpwgt[0]) {
where[i] = 0;
pwgts[0] += vwgt[i];
pwgts[1] -= vwgt[i];
if (pwgts[0] > minpwgt[0])
break;
}
}
}
/*************************************************************
* Do some partition refinement
**************************************************************/
Compute2WayPartitionParams(ctrl, graph);
/* printf("IPART: %3d [%5d %5d] [%5d %5d] %5d\n", graph->nvtxs, pwgts[0], pwgts[1], graph->pwgts[0], graph->pwgts[1], graph->mincut); */
Balance2Way(ctrl, graph, tpwgts, ubfactor);
/* printf("BPART: [%5d %5d] %5d\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */
FM_2WayEdgeRefine(ctrl, graph, tpwgts, 4);
/* printf("RPART: [%5d %5d] %5d\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */
if (bestcut > graph->mincut) {
bestcut = graph->mincut;
idxcopy(nvtxs, where, bestwhere);
if (bestcut == 0)
break;
}
}
graph->mincut = bestcut;
idxcopy(nvtxs, bestwhere, where);
GKfree(&bestwhere, &perm, LTERM);
}
/*************************************************************************
* This function performs k-way refinement
**************************************************************************/
void Moc_KWayFM(CtrlType *ctrl, GraphType *graph, WorkSpaceType *wspace, int npasses)
{
int h, i, ii, iii, j, k, c;
int pass, nvtxs, nedges, ncon;
int nmoves, nmoved, nswaps, nzgswaps;
/* int gnswaps, gnzgswaps; */
int me, firstvtx, lastvtx, yourlastvtx;
int from, to = -1, oldto, oldcut, mydomain, yourdomain, imbalanced, overweight;
int npes = ctrl->npes, mype = ctrl->mype, nparts = ctrl->nparts;
int nlupd, nsupd, nnbrs, nchanged;
idxtype *xadj, *ladjncy, *adjwgt, *vtxdist;
idxtype *where, *tmp_where, *moved;
floattype *lnpwgts, *gnpwgts, *ognpwgts, *pgnpwgts, *movewgts, *overfill;
idxtype *update, *supdate, *rupdate, *pe_updates;
idxtype *changed, *perm, *pperm, *htable;
idxtype *peind, *recvptr, *sendptr;
KeyValueType *swchanges, *rwchanges;
RInfoType *rinfo, *myrinfo, *tmp_myrinfo, *tmp_rinfo;
EdgeType *tmp_edegrees, *my_edegrees, *your_edegrees;
floattype lbvec[MAXNCON], *nvwgt, *badmaxpwgt, *ubvec, *tpwgts, lbavg, ubavg;
int *nupds_pe;
IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->KWayTmr));
/*************************/
/* set up common aliases */
/*************************/
nvtxs = graph->nvtxs;
nedges = graph->nedges;
ncon = graph->ncon;
vtxdist = graph->vtxdist;
xadj = graph->xadj;
ladjncy = graph->adjncy;
adjwgt = graph->adjwgt;
firstvtx = vtxdist[mype];
lastvtx = vtxdist[mype+1];
where = graph->where;
rinfo = graph->rinfo;
lnpwgts = graph->lnpwgts;
gnpwgts = graph->gnpwgts;
ubvec = ctrl->ubvec;
tpwgts = ctrl->tpwgts;
nnbrs = graph->nnbrs;
peind = graph->peind;
recvptr = graph->recvptr;
sendptr = graph->sendptr;
changed = idxmalloc(nvtxs, "KWR: changed");
rwchanges = wspace->pairs;
swchanges = rwchanges + recvptr[nnbrs];
/************************************/
/* set up important data structures */
/************************************/
perm = idxmalloc(nvtxs, "KWR: perm");
pperm = idxmalloc(nparts, "KWR: pperm");
update = idxmalloc(nvtxs, "KWR: update");
supdate = wspace->indices;
rupdate = supdate + recvptr[nnbrs];
nupds_pe = imalloc(npes, "KWR: nupds_pe");
htable = idxsmalloc(nvtxs+graph->nrecv, 0, "KWR: lhtable");
badmaxpwgt = fmalloc(nparts*ncon, "badmaxpwgt");
for (i=0; i<nparts; i++) {
for (h=0; h<ncon; h++) {
badmaxpwgt[i*ncon+h] = ubvec[h]*tpwgts[i*ncon+h];
}
}
movewgts = fmalloc(nparts*ncon, "KWR: movewgts");
ognpwgts = fmalloc(nparts*ncon, "KWR: ognpwgts");
pgnpwgts = fmalloc(nparts*ncon, "KWR: pgnpwgts");
overfill = fmalloc(nparts*ncon, "KWR: overfill");
moved = idxmalloc(nvtxs, "KWR: moved");
tmp_where = idxmalloc(nvtxs+graph->nrecv, "KWR: tmp_where");
tmp_rinfo = (RInfoType *)GKmalloc(sizeof(RInfoType)*nvtxs, "KWR: tmp_rinfo");
tmp_edegrees = (EdgeType *)GKmalloc(sizeof(EdgeType)*nedges, "KWR: tmp_edegrees");
idxcopy(nvtxs+graph->nrecv, where, tmp_where);
for (i=0; i<nvtxs; i++) {
tmp_rinfo[i].id = rinfo[i].id;
tmp_rinfo[i].ed = rinfo[i].ed;
tmp_rinfo[i].ndegrees = rinfo[i].ndegrees;
tmp_rinfo[i].degrees = tmp_edegrees+xadj[i];
for (j=0; j<rinfo[i].ndegrees; j++) {
tmp_rinfo[i].degrees[j].edge = rinfo[i].degrees[j].edge;
tmp_rinfo[i].degrees[j].ewgt = rinfo[i].degrees[j].ewgt;
}
}
nswaps = nzgswaps = 0;
/*********************************************************/
/* perform a small number of passes through the vertices */
/*********************************************************/
for (pass=0; pass<npasses; pass++) {
if (mype == 0)
RandomPermute(nparts, pperm, 1);
MPI_Bcast((void *)pperm, nparts, IDX_DATATYPE, 0, ctrl->comm);
FastRandomPermute(nvtxs, perm, 1);
oldcut = graph->mincut;
/* check to see if the partitioning is imbalanced */
Moc_ComputeParallelBalance(ctrl, graph, graph->where, lbvec);
ubavg = savg(ncon, ubvec);
lbavg = savg(ncon, lbvec);
imbalanced = (lbavg > ubavg) ? 1 : 0;
for (c=0; c<2; c++) {
scopy(ncon*nparts, gnpwgts, ognpwgts);
sset(ncon*nparts, 0.0, movewgts);
nmoved = 0;
/**********************************************/
/* PASS ONE -- record stats for desired moves */
/**********************************************/
for (iii=0; iii<nvtxs; iii++) {
i = perm[iii];
from = tmp_where[i];
nvwgt = graph->nvwgt+i*ncon;
for (h=0; h<ncon; h++)
if (fabs(nvwgt[h]-gnpwgts[from*ncon+h]) < SMALLFLOAT)
break;
if (h < ncon) {
continue;
}
/* check for a potential improvement */
if (tmp_rinfo[i].ed >= tmp_rinfo[i].id) {
my_edegrees = tmp_rinfo[i].degrees;
for (k=0; k<tmp_rinfo[i].ndegrees; k++) {
to = my_edegrees[k].edge;
if (ProperSide(c, pperm[from], pperm[to])) {
for (h=0; h<ncon; h++)
if (gnpwgts[to*ncon+h]+nvwgt[h] > badmaxpwgt[to*ncon+h] && nvwgt[h] > 0.0)
break;
if (h == ncon)
break;
}
}
oldto = to;
/* check if a subdomain was found that fits */
if (k < tmp_rinfo[i].ndegrees) {
for (j=k+1; j<tmp_rinfo[i].ndegrees; j++) {
to = my_edegrees[j].edge;
if (ProperSide(c, pperm[from], pperm[to])) {
for (h=0; h<ncon; h++)
if (gnpwgts[to*ncon+h]+nvwgt[h] > badmaxpwgt[to*ncon+h] && nvwgt[h] > 0.0)
break;
if (h == ncon) {
if (my_edegrees[j].ewgt > my_edegrees[k].ewgt ||
(my_edegrees[j].ewgt == my_edegrees[k].ewgt &&
IsHBalanceBetterTT(ncon,gnpwgts+oldto*ncon,gnpwgts+to*ncon,nvwgt,ubvec))){
k = j;
oldto = my_edegrees[k].edge;
}
}
}
}
to = oldto;
if (my_edegrees[k].ewgt > tmp_rinfo[i].id ||
(my_edegrees[k].ewgt == tmp_rinfo[i].id &&
(imbalanced || graph->level > 3 || iii % 8 == 0) &&
IsHBalanceBetterFT(ncon,gnpwgts+from*ncon,gnpwgts+to*ncon,nvwgt,ubvec))){
/****************************************/
/* Update tmp arrays of the moved vertex */
/****************************************/
tmp_where[i] = to;
moved[nmoved++] = i;
for (h=0; h<ncon; h++) {
lnpwgts[to*ncon+h] += nvwgt[h];
lnpwgts[from*ncon+h] -= nvwgt[h];
gnpwgts[to*ncon+h] += nvwgt[h];
gnpwgts[from*ncon+h] -= nvwgt[h];
movewgts[to*ncon+h] += nvwgt[h];
movewgts[from*ncon+h] -= nvwgt[h];
}
tmp_rinfo[i].ed += tmp_rinfo[i].id-my_edegrees[k].ewgt;
SWAP(tmp_rinfo[i].id, my_edegrees[k].ewgt, j);
if (my_edegrees[k].ewgt == 0) {
tmp_rinfo[i].ndegrees--;
my_edegrees[k].edge = my_edegrees[tmp_rinfo[i].ndegrees].edge;
my_edegrees[k].ewgt = my_edegrees[tmp_rinfo[i].ndegrees].ewgt;
}
else {
my_edegrees[k].edge = from;
}
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
/* no need to bother about vertices on different pe's */
if (ladjncy[j] >= nvtxs)
continue;
me = ladjncy[j];
mydomain = tmp_where[me];
myrinfo = tmp_rinfo+me;
your_edegrees = myrinfo->degrees;
if (mydomain == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
}
else {
if (mydomain == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
}
}
/* Remove contribution from the .ed of 'from' */
if (mydomain != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (your_edegrees[k].edge == from) {
if (your_edegrees[k].ewgt == adjwgt[j]) {
myrinfo->ndegrees--;
your_edegrees[k].edge = your_edegrees[myrinfo->ndegrees].edge;
your_edegrees[k].ewgt = your_edegrees[myrinfo->ndegrees].ewgt;
}
else {
your_edegrees[k].ewgt -= adjwgt[j];
}
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (mydomain != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (your_edegrees[k].edge == to) {
your_edegrees[k].ewgt += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
your_edegrees[myrinfo->ndegrees].edge = to;
your_edegrees[myrinfo->ndegrees++].ewgt = adjwgt[j];
}
}
}
}
}
}
}
/******************************************/
/* Let processors know the subdomain wgts */
/* if all proposed moves commit. */
/******************************************/
MPI_Allreduce((void *)lnpwgts, (void *)pgnpwgts, nparts*ncon,
MPI_DOUBLE, MPI_SUM, ctrl->comm);
/**************************/
/* compute overfill array */
/**************************/
overweight = 0;
for (j=0; j<nparts; j++) {
for (h=0; h<ncon; h++) {
if (pgnpwgts[j*ncon+h] > ognpwgts[j*ncon+h]) {
overfill[j*ncon+h] =
(pgnpwgts[j*ncon+h]-badmaxpwgt[j*ncon+h]) /
(pgnpwgts[j*ncon+h]-ognpwgts[j*ncon+h]);
}
else {
overfill[j*ncon+h] = 0.0;
}
overfill[j*ncon+h] = amax(overfill[j*ncon+h], 0.0);
overfill[j*ncon+h] *= movewgts[j*ncon+h];
if (overfill[j*ncon+h] > 0.0)
overweight = 1;
ASSERTP(ctrl, ognpwgts[j*ncon+h] <= badmaxpwgt[j*ncon+h] ||
pgnpwgts[j*ncon+h] <= ognpwgts[j*ncon+h],
(ctrl, "%.4f %.4f %.4f\n", ognpwgts[j*ncon+h],
badmaxpwgt[j*ncon+h], pgnpwgts[j*ncon+h]));
}
}
/****************************************************/
/* select moves to undo according to overfill array */
/****************************************************/
if (overweight == 1) {
for (iii=0; iii<nmoved; iii++) {
i = moved[iii];
oldto = tmp_where[i];
nvwgt = graph->nvwgt+i*ncon;
my_edegrees = tmp_rinfo[i].degrees;
for (k=0; k<tmp_rinfo[i].ndegrees; k++)
if (my_edegrees[k].edge == where[i])
break;
for (h=0; h<ncon; h++)
if (nvwgt[h] > 0.0 && overfill[oldto*ncon+h] > nvwgt[h]/4.0)
break;
/**********************************/
/* nullify this move if necessary */
/**********************************/
if (k != tmp_rinfo[i].ndegrees && h != ncon) {
moved[iii] = -1;
from = oldto;
to = where[i];
for (h=0; h<ncon; h++) {
overfill[oldto*ncon+h] = amax(overfill[oldto*ncon+h]-nvwgt[h], 0.0);
}
tmp_where[i] = to;
tmp_rinfo[i].ed += tmp_rinfo[i].id-my_edegrees[k].ewgt;
SWAP(tmp_rinfo[i].id, my_edegrees[k].ewgt, j);
if (my_edegrees[k].ewgt == 0) {
tmp_rinfo[i].ndegrees--;
my_edegrees[k].edge = my_edegrees[tmp_rinfo[i].ndegrees].edge;
my_edegrees[k].ewgt = my_edegrees[tmp_rinfo[i].ndegrees].ewgt;
}
else {
my_edegrees[k].edge = from;
}
for (h=0; h<ncon; h++) {
lnpwgts[to*ncon+h] += nvwgt[h];
lnpwgts[from*ncon+h] -= nvwgt[h];
}
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
/* no need to bother about vertices on different pe's */
if (ladjncy[j] >= nvtxs)
continue;
me = ladjncy[j];
mydomain = tmp_where[me];
myrinfo = tmp_rinfo+me;
your_edegrees = myrinfo->degrees;
if (mydomain == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
}
else {
if (mydomain == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
}
}
/* Remove contribution from the .ed of 'from' */
if (mydomain != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (your_edegrees[k].edge == from) {
if (your_edegrees[k].ewgt == adjwgt[j]) {
myrinfo->ndegrees--;
your_edegrees[k].edge = your_edegrees[myrinfo->ndegrees].edge;
your_edegrees[k].ewgt = your_edegrees[myrinfo->ndegrees].ewgt;
}
else {
your_edegrees[k].ewgt -= adjwgt[j];
}
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (mydomain != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (your_edegrees[k].edge == to) {
your_edegrees[k].ewgt += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
your_edegrees[myrinfo->ndegrees].edge = to;
your_edegrees[myrinfo->ndegrees++].ewgt = adjwgt[j];
}
}
}
}
}
}
/*************************************************/
/* PASS TWO -- commit the remainder of the moves */
/*************************************************/
nlupd = nsupd = nmoves = nchanged = 0;
for (iii=0; iii<nmoved; iii++) {
i = moved[iii];
if (i == -1)
continue;
where[i] = tmp_where[i];
/* Make sure to update the vertex information */
if (htable[i] == 0) {
/* make sure you do the update */
htable[i] = 1;
update[nlupd++] = i;
}
/* Put the vertices adjacent to i into the update array */
for (j=xadj[i]; j<xadj[i+1]; j++) {
k = ladjncy[j];
if (htable[k] == 0) {
htable[k] = 1;
if (k<nvtxs)
update[nlupd++] = k;
else
supdate[nsupd++] = k;
}
}
nmoves++;
nswaps++;
/* check number of zero-gain moves */
for (k=0; k<rinfo[i].ndegrees; k++)
if (rinfo[i].degrees[k].edge == to)
break;
if (rinfo[i].id == rinfo[i].degrees[k].ewgt)
nzgswaps++;
if (graph->pexadj[i+1]-graph->pexadj[i] > 0)
changed[nchanged++] = i;
}
/* Tell interested pe's the new where[] info for the interface vertices */
CommChangedInterfaceData(ctrl, graph, nchanged, changed, where,
swchanges, rwchanges, wspace->pv4);
IFSET(ctrl->dbglvl, DBG_RMOVEINFO,
rprintf(ctrl, "\t[%d %d], [%.4f], [%d %d %d]\n",
pass, c, badmaxpwgt[0],
GlobalSESum(ctrl, nmoves),
GlobalSESum(ctrl, nsupd),
GlobalSESum(ctrl, nlupd)));
/*-------------------------------------------------------------
/ Time to communicate with processors to send the vertices
/ whose degrees need to be update.
/-------------------------------------------------------------*/
/* Issue the receives first */
for (i=0; i<nnbrs; i++) {
MPI_Irecv((void *)(rupdate+sendptr[i]), sendptr[i+1]-sendptr[i], IDX_DATATYPE,
peind[i], 1, ctrl->comm, ctrl->rreq+i);
}
/* Issue the sends next. This needs some preporcessing */
for (i=0; i<nsupd; i++) {
htable[supdate[i]] = 0;
supdate[i] = graph->imap[supdate[i]];
}
iidxsort(nsupd, supdate);
for (j=i=0; i<nnbrs; i++) {
yourlastvtx = vtxdist[peind[i]+1];
for (k=j; k<nsupd && supdate[k] < yourlastvtx; k++);
MPI_Isend((void *)(supdate+j), k-j, IDX_DATATYPE, peind[i], 1, ctrl->comm, ctrl->sreq+i);
j = k;
}
/* OK, now get into the loop waiting for the send/recv operations to finish */
MPI_Waitall(nnbrs, ctrl->rreq, ctrl->statuses);
for (i=0; i<nnbrs; i++)
MPI_Get_count(ctrl->statuses+i, IDX_DATATYPE, nupds_pe+i);
MPI_Waitall(nnbrs, ctrl->sreq, ctrl->statuses);
/*-------------------------------------------------------------
/ Place the recieved to-be updated vertices into update[]
/-------------------------------------------------------------*/
for (i=0; i<nnbrs; i++) {
pe_updates = rupdate+sendptr[i];
for (j=0; j<nupds_pe[i]; j++) {
k = pe_updates[j];
if (htable[k-firstvtx] == 0) {
htable[k-firstvtx] = 1;
update[nlupd++] = k-firstvtx;
}
}
}
/*-------------------------------------------------------------
/ Update the rinfo of the vertices in the update[] array
/-------------------------------------------------------------*/
for (ii=0; ii<nlupd; ii++) {
i = update[ii];
ASSERT(ctrl, htable[i] == 1);
htable[i] = 0;
mydomain = where[i];
myrinfo = rinfo+i;
tmp_myrinfo = tmp_rinfo+i;
my_edegrees = myrinfo->degrees;
your_edegrees = tmp_myrinfo->degrees;
graph->lmincut -= myrinfo->ed;
myrinfo->ndegrees = 0;
myrinfo->id = 0;
myrinfo->ed = 0;
for (j=xadj[i]; j<xadj[i+1]; j++) {
yourdomain = where[ladjncy[j]];
if (mydomain != yourdomain) {
myrinfo->ed += adjwgt[j];
for (k=0; k<myrinfo->ndegrees; k++) {
if (my_edegrees[k].edge == yourdomain) {
my_edegrees[k].ewgt += adjwgt[j];
your_edegrees[k].ewgt += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
my_edegrees[k].edge = yourdomain;
my_edegrees[k].ewgt = adjwgt[j];
your_edegrees[k].edge = yourdomain;
your_edegrees[k].ewgt = adjwgt[j];
myrinfo->ndegrees++;
}
ASSERT(ctrl, myrinfo->ndegrees <= xadj[i+1]-xadj[i]);
ASSERT(ctrl, tmp_myrinfo->ndegrees <= xadj[i+1]-xadj[i]);
}
else {
myrinfo->id += adjwgt[j];
}
}
graph->lmincut += myrinfo->ed;
tmp_myrinfo->id = myrinfo->id;
tmp_myrinfo->ed = myrinfo->ed;
tmp_myrinfo->ndegrees = myrinfo->ndegrees;
}
/* finally, sum-up the partition weights */
MPI_Allreduce((void *)lnpwgts, (void *)gnpwgts, nparts*ncon,
MPI_DOUBLE, MPI_SUM, ctrl->comm);
}
graph->mincut = GlobalSESum(ctrl, graph->lmincut)/2;
if (graph->mincut == oldcut)
break;
}
/*
gnswaps = GlobalSESum(ctrl, nswaps);
gnzgswaps = GlobalSESum(ctrl, nzgswaps);
if (mype == 0)
printf("niters: %d, nswaps: %d, nzgswaps: %d\n", pass+1, gnswaps, gnzgswaps);
*/
GKfree((void **)&badmaxpwgt, (void **)&update, (void **)&nupds_pe, (void **)&htable, LTERM);
GKfree((void **)&changed, (void **)&pperm, (void **)&perm, (void **)&moved, LTERM);
GKfree((void **)&pgnpwgts, (void **)&ognpwgts, (void **)&overfill, (void **)&movewgts, LTERM);
GKfree((void **)&tmp_where, (void **)&tmp_rinfo, (void **)&tmp_edegrees, LTERM);
IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->KWayTmr));
}
/*************************************************************************
* This function performs an edge-based FM refinement
**************************************************************************/
void MocGeneral2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts, float lbfactor)
{
int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum;
idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
idxtype *moved, *swaps, *perm, *qnum;
float *nvwgt, *npwgts, mindiff[MAXNCON], origbal, minbal, newbal;
PQueueType parts[MAXNCON][2];
int higain, oldgain, mincut, newcut, mincutorder;
int qsizes[MAXNCON][2];
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
nvwgt = graph->nvwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
npwgts = graph->npwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
moved = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
qnum = idxwspacemalloc(ctrl, nvtxs);
limit = amin(amax(0.01*nvtxs, 15), 100);
/* Initialize the queues */
for (i=0; i<ncon; i++) {
PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
qsizes[i][0] = qsizes[i][1] = 0;
}
for (i=0; i<nvtxs; i++) {
qnum[i] = samax(ncon, nvwgt+i*ncon);
qsizes[qnum[i]][where[i]]++;
}
/*
printf("Weight Distribution: \t");
for (i=0; i<ncon; i++)
printf(" [%d %d]", qsizes[i][0], qsizes[i][1]);
printf("\n");
*/
for (from=0; from<2; from++) {
for (j=0; j<ncon; j++) {
if (qsizes[j][from] == 0) {
for (i=0; i<nvtxs; i++) {
if (where[i] != from)
continue;
k = samax2(ncon, nvwgt+i*ncon);
if (k == j && qsizes[qnum[i]][from] > qsizes[j][from] && nvwgt[i*ncon+qnum[i]] < 1.3*nvwgt[i*ncon+j]) {
qsizes[qnum[i]][from]--;
qsizes[j][from]++;
qnum[i] = j;
}
}
}
}
}
/*
printf("Weight Distribution (after):\t ");
for (i=0; i<ncon; i++)
printf(" [%d %d]", qsizes[i][0], qsizes[i][1]);
printf("\n");
*/
for (i=0; i<ncon; i++)
mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
minbal = origbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
newcut = mincut = graph->mincut;
mincutorder = -1;
if (ctrl->dbglvl&DBG_REFINE) {
printf("Parts: [");
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f [B]\n", tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut, origbal);
}
idxset(nvtxs, -1, moved);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert all nodes in the priority queues */
nbnd = graph->nbnd;
RandomPermute(nvtxs, perm, 1);
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
}
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if (minbal < lbfactor)
break;
SelectQueue(ncon, npwgts, tpwgts, &from, &cnum, parts);
to = (from+1)%2;
if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
break;
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
newcut -= (ed[higain]-id[higain]);
newbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
if (newbal < minbal || (newbal == minbal &&
(newcut < mincut || (newcut == mincut && BetterBalance(ncon, npwgts, tpwgts, mindiff))))) {
mincut = newcut;
minbal = newbal;
mincutorder = nswaps;
for (i=0; i<ncon; i++)
mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
}
else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
newcut += (ed[higain]-id[higain]);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
break;
}
where[higain] = to;
moved[higain] = nswaps;
swaps[nswaps] = higain;
if (ctrl->dbglvl&DBG_MOVEINFO) {
printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf(", %.3f LB: %.3f\n", minbal, newbal);
}
/**************************************************************
* Update the id[i]/ed[i] values of the affected nodes
***************************************************************/
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
oldgain = ed[k]-id[k];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
/* Update the queue position */
if (moved[k] == -1)
PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, ed[k]-id[k]);
/* Update its boundary information */
if (ed[k] == 0 && bndptr[k] != -1)
BNDDelete(nbnd, bndind, bndptr, k);
else if (ed[k] > 0 && bndptr[k] == -1)
BNDInsert(nbnd, bndind, bndptr, k);
}
}
/****************************************************************
* Roll back computations
*****************************************************************/
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);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((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);
}
}
if (ctrl->dbglvl&DBG_REFINE) {
printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("], LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
}
graph->mincut = mincut;
graph->nbnd = nbnd;
for (i=0; i<ncon; i++) {
PQueueFree(ctrl, &parts[i][0]);
PQueueFree(ctrl, &parts[i][1]);
}
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs k-way refinement
**************************************************************************/
void Greedy_KWayEdgeBalanceMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses)
{
int i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain, nmoves;
int from, me, to, oldcut, vwgt, maxndoms, nadd;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts;
idxtype *phtable, *pmat, *pmatptr, *ndoms;
EDegreeType *myedegrees;
RInfoType *myrinfo;
PQueueType queue;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
bndind = graph->bndind;
bndptr = graph->bndptr;
where = graph->where;
pwgts = graph->pwgts;
pmat = ctrl->wspace.pmat;
phtable = idxwspacemalloc(ctrl, nparts);
ndoms = idxwspacemalloc(ctrl, nparts);
ComputeSubDomainGraph(graph, nparts, pmat, ndoms);
/* Setup the weight intervals of the various subdomains */
minwgt = idxwspacemalloc(ctrl, nparts);
maxwgt = idxwspacemalloc(ctrl, nparts);
itpwgts = idxwspacemalloc(ctrl, nparts);
tvwgt = idxsum(nparts, pwgts);
ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
for (i=0; i<nparts; i++) {
itpwgts[i] = tpwgts[i]*tvwgt;
maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
}
perm = idxwspacemalloc(ctrl, nvtxs);
moved = idxwspacemalloc(ctrl, nvtxs);
PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d [B]\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
graph->mincut));
for (pass=0; pass<npasses; pass++) {
ASSERT(ComputeCut(graph, where) == graph->mincut);
/* Check to see if things are out of balance, given the tolerance */
for (i=0; i<nparts; i++) {
if (pwgts[i] > maxwgt[i])
break;
}
if (i == nparts) /* Things are balanced. Return right away */
break;
PQueueReset(&queue);
idxset(nvtxs, -1, moved);
oldcut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
moved[i] = 2;
}
maxndoms = ndoms[idxamax(nparts, ndoms)];
for (nmoves=0;;) {
if ((i = PQueueGetMax(&queue)) == -1)
break;
moved[i] = 1;
myrinfo = graph->rinfo+i;
from = where[i];
vwgt = graph->vwgt[i];
if (pwgts[from]-vwgt < minwgt[from])
continue; /* This cannot be moved! */
myedegrees = myrinfo->edegrees;
myndegrees = myrinfo->ndegrees;
/* Determine the valid domains */
for (j=0; j<myndegrees; j++) {
to = myedegrees[j].pid;
phtable[to] = 1;
pmatptr = pmat + to*nparts;
for (nadd=0, k=0; k<myndegrees; k++) {
if (k == j)
continue;
l = myedegrees[k].pid;
if (pmatptr[l] == 0) {
if (ndoms[l] > maxndoms-1) {
phtable[to] = 0;
nadd = maxndoms;
break;
}
nadd++;
}
}
if (ndoms[to]+nadd > maxndoms)
phtable[to] = 0;
}
for (k=0; k<myndegrees; k++) {
to = myedegrees[k].pid;
if (!phtable[to])
continue;
if (pwgts[to]+vwgt <= maxwgt[to] || itpwgts[from]*(pwgts[to]+vwgt) <= itpwgts[to]*pwgts[from])
break;
}
if (k == myndegrees)
continue; /* break out if you did not find a candidate */
for (j=k+1; j<myndegrees; j++) {
to = myedegrees[j].pid;
if (!phtable[to])
continue;
if (itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid])
k = j;
}
to = myedegrees[k].pid;
if (pwgts[from] < maxwgt[from] && pwgts[to] > minwgt[to] && myedegrees[k].ed-myrinfo->id < 0)
continue;
/*=====================================================================
* If we got here, we can now move the vertex from 'from' to 'to'
*======================================================================*/
graph->mincut -= myedegrees[k].ed-myrinfo->id;
IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
/* Update pmat to reflect the move of 'i' */
pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
if (pmat[from*nparts+to] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[to*nparts+from] == 0) {
ndoms[to]--;
if (ndoms[to]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
/* Update where, weight, and ID/ED information of the vertex you moved */
where[i] = to;
INC_DEC(pwgts[to], pwgts[from], vwgt);
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed == 0)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
oldgain = (myrinfo->ed-myrinfo->id);
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed > 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed == 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
/* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
if (me != from && me != to) {
pmat[me*nparts+from] -= adjwgt[j];
pmat[from*nparts+me] -= adjwgt[j];
if (pmat[me*nparts+from] == 0) {
ndoms[me]--;
if (ndoms[me]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[from*nparts+me] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[me*nparts+to] == 0) {
ndoms[me]++;
if (ndoms[me] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
maxndoms = ndoms[me];
}
}
if (pmat[to*nparts+me] == 0) {
ndoms[to]++;
if (ndoms[to] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
maxndoms = ndoms[to];
}
}
pmat[me*nparts+to] += adjwgt[j];
pmat[to*nparts+me] += adjwgt[j];
}
/* Update the queue */
if (me == to || me == from) {
gain = myrinfo->ed-myrinfo->id;
if (moved[ii] == 2) {
if (myrinfo->ed > 0)
PQueueUpdate(&queue, ii, oldgain, gain);
else {
PQueueDelete(&queue, ii, oldgain);
moved[ii] = -1;
}
}
else if (moved[ii] == -1 && myrinfo->ed > 0) {
PQueueInsert(&queue, ii, gain);
moved[ii] = 2;
}
}
ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
ASSERT(CheckRInfo(myrinfo));
}
nmoves++;
}
graph->nbnd = nbnd;
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, %d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut,idxsum(nparts, ndoms)));
}
PQueueFree(ctrl, &queue);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
/*************************************************************************
* This function performs k-way refinement
**************************************************************************/
void Greedy_KWayEdgeRefine(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses)
{
int i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain;
int from, me, to, oldcut, vwgt;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts;
EDegreeType *myedegrees;
RInfoType *myrinfo;
PQueueType queue;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
bndind = graph->bndind;
bndptr = graph->bndptr;
where = graph->where;
pwgts = graph->pwgts;
/* Setup the weight intervals of the various subdomains */
minwgt = idxwspacemalloc(ctrl, nparts);
maxwgt = idxwspacemalloc(ctrl, nparts);
itpwgts = idxwspacemalloc(ctrl, nparts);
tvwgt = idxsum(nparts, pwgts);
ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
for (i=0; i<nparts; i++) {
itpwgts[i] = tpwgts[i]*tvwgt;
maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
}
perm = idxwspacemalloc(ctrl, nvtxs);
moved = idxwspacemalloc(ctrl, nvtxs);
PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
graph->mincut));
for (pass=0; pass<npasses; pass++) {
ASSERT(ComputeCut(graph, where) == graph->mincut);
PQueueReset(&queue);
idxset(nvtxs, -1, moved);
oldcut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
moved[i] = 2;
}
for (iii=0;; iii++) {
if ((i = PQueueGetMax(&queue)) == -1)
break;
moved[i] = 1;
myrinfo = graph->rinfo+i;
from = where[i];
vwgt = graph->vwgt[i];
if (pwgts[from]-vwgt < minwgt[from])
continue; /* This cannot be moved! */
myedegrees = myrinfo->edegrees;
myndegrees = myrinfo->ndegrees;
j = myrinfo->id;
for (k=0; k<myndegrees; k++) {
to = myedegrees[k].pid;
gain = myedegrees[k].ed-j; /* j = myrinfo->id. Allow good nodes to move */
if (pwgts[to]+vwgt <= maxwgt[to]+gain && gain >= 0)
break;
}
if (k == myndegrees)
continue; /* break out if you did not find a candidate */
for (j=k+1; j<myndegrees; j++) {
to = myedegrees[j].pid;
if ((myedegrees[j].ed > myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) ||
(myedegrees[j].ed == myedegrees[k].ed &&
itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
k = j;
}
to = myedegrees[k].pid;
j = 0;
if (myedegrees[k].ed-myrinfo->id > 0)
j = 1;
else if (myedegrees[k].ed-myrinfo->id == 0) {
if ((iii&7) == 0 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
j = 1;
}
if (j == 0)
continue;
/*=====================================================================
* If we got here, we can now move the vertex from 'from' to 'to'
*======================================================================*/
graph->mincut -= myedegrees[k].ed-myrinfo->id;
IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
/* Update where, weight, and ID/ED information of the vertex you moved */
where[i] = to;
INC_DEC(pwgts[to], pwgts[from], vwgt);
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed < myrinfo->id)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
oldgain = (myrinfo->ed-myrinfo->id);
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
/* Update the queue */
if (me == to || me == from) {
gain = myrinfo->ed-myrinfo->id;
if (moved[ii] == 2) {
if (gain >= 0)
PQueueUpdate(&queue, ii, oldgain, gain);
else {
PQueueDelete(&queue, ii, oldgain);
moved[ii] = -1;
}
}
else if (moved[ii] == -1 && gain >= 0) {
PQueueInsert(&queue, ii, gain);
moved[ii] = 2;
}
}
ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
ASSERT(CheckRInfo(myrinfo));
}
}
graph->nbnd = nbnd;
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Cut: %6d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, graph->mincut));
if (graph->mincut == oldcut)
break;
}
PQueueFree(ctrl, &queue);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}