void
improveDDSep(domdec_t *dd)
{ bucket_t *b_bucket, *w_bucket;
PORD_INT *xadj, *adjncy, *vwght, *vtype, *color, *cwght;
PORD_INT *tmp_color, *deltaS, *deltaB, *deltaW;
PORD_INT nvtx, weight, tmp_S, tmp_B, tmp_W;
PORD_INT pos, bestglobalpos, badflips, b_domain, w_domain, domain, nxtdomain;
PORD_INT fhead, ftail, u, v, i, istart, istop;
FLOAT bestglobalvalue, b_value, w_value, value;
/* ======================================================================
vtype[u]: (u domain)
1 => color of domain u has not been changed
< 0 => points to next domain in flipping list
(fhead points to first, ftail points to last domain in list)
= 0 => domain is last domain in flipping list
====================================================================== */
nvtx = dd->G->nvtx;
xadj = dd->G->xadj;
adjncy = dd->G->adjncy;
vwght = dd->G->vwght;
vtype = dd->vtype;
color = dd->color;
cwght = dd->cwght;
mymalloc(tmp_color, nvtx, PORD_INT);
mymalloc(deltaS, nvtx, PORD_INT);
mymalloc(deltaB, nvtx, PORD_INT);
mymalloc(deltaW, nvtx, PORD_INT);
OUTER_LOOP_START:
/* ----------------------------------------------------------------------
copy data of actual bisection and initialize buckets and flipping list
---------------------------------------------------------------------- */
tmp_S = cwght[GRAY];
tmp_B = cwght[BLACK];
tmp_W = cwght[WHITE];
bestglobalpos = badflips = 0;
bestglobalvalue = F(tmp_S, tmp_B, tmp_W);
b_bucket = setupBucket(nvtx, nvtx, (nvtx >> 1));
w_bucket = setupBucket(nvtx, nvtx, (nvtx >> 1));
fhead = 0; ftail = -1;
pos = 0;
/* ----------------------------------------------------------
initialize tmp_color, deltaB, and deltaW for all multisecs
---------------------------------------------------------- */
for (u = 0; u < nvtx; u++)
if (vtype[u] == 2)
{ deltaB[u] = deltaW[u] = 0;
istart = xadj[u];
istop = xadj[u+1];
for (i = istart; i < istop; i++)
{ v = adjncy[i];
if (color[v] == BLACK) deltaB[u]++;
else deltaW[u]++;
}
if ((deltaB[u] > 0) && (deltaW[u] > 0)) /* update multisec coloring */
tmp_color[u] = GRAY;
else if (deltaB[u] > 0) tmp_color[u] = BLACK;
else tmp_color[u] = WHITE;
color[u] = tmp_color[u];
}
/* -----------------------------------------------------------------
initialize tmp_color, deltaS,B,W for all domains and fill buckets
----------------------------------------------------------------- */
for (u = 0; u < nvtx; u++)
if (vtype[u] == 1)
{ tmp_color[u] = color[u];
if (tmp_color[u] == BLACK) /* domain may be flipped to WHITE */
{ deltaW[u] = vwght[u]; deltaB[u] = -deltaW[u]; deltaS[u] = 0;
istart = xadj[u];
istop = xadj[u+1];
for (i = istart; i < istop; i++)
{ v = adjncy[i]; /* tmp_color[v] e {GRAY, BLACK} */
weight = vwght[v];
if (tmp_color[v] == BLACK) /* multisec v will move into S */
{ deltaB[u] -= weight;
deltaS[u] += weight;
}
else if (deltaB[v] == 1) /* multisec v will move into W */
{ deltaW[u] += weight;
deltaS[u] -= weight;
deltaB[v] = -(u+1);
}
}
insertBucket(b_bucket, deltaS[u], u);
}
if (tmp_color[u] == WHITE) /* domain may be flipped to BLACK */
{ deltaB[u] = vwght[u]; deltaW[u] = -deltaB[u]; deltaS[u] = 0;
istart = xadj[u];
istop = xadj[u+1];
for (i = istart; i < istop; i++)
{ v = adjncy[i]; /* tmp_color[v] e {GRAY, WHITE} */
weight = vwght[v];
if (tmp_color[v] == WHITE) /* multisec v will move into S */
{ deltaW[u] -= weight;
deltaS[u] += weight;
}
else if (deltaW[v] == 1) /* multisec v will move into B */
{ deltaB[u] += weight;
deltaS[u] -= weight;
deltaW[v] = -(u+1);
}
}
insertBucket(w_bucket, deltaS[u], u);
}
}
#ifdef DEBUG
printf("starting inner loop: b_bucket->nobj %d, w_bucket->nobj %d\n",
b_bucket->nobj, w_bucket->nobj);
waitkey();
#endif
INNER_LOOP_START:
/* -------------------------------------------
extract best domain from b_bucket, w_bucket
------------------------------------------- */
b_value = w_value = MAX_FLOAT;
if ((b_domain = minBucket(b_bucket)) != -1)
{ b_value = F((tmp_S+deltaS[b_domain]), (tmp_B+deltaB[b_domain]),
(tmp_W+deltaW[b_domain]));
#ifdef DEBUG
printf("best black domain: %d, deltaS %d, deltaB %d, deltaW %d, "
"cost %7.2f\n", b_domain, deltaS[b_domain], deltaB[b_domain],
deltaW[b_domain], b_value);
#endif
}
if ((w_domain = minBucket(w_bucket)) != -1)
{ w_value = F((tmp_S+deltaS[w_domain]), (tmp_B+deltaB[w_domain]),
(tmp_W+deltaW[w_domain]));
#ifdef DEBUG
printf("best white domain: %d, deltaS %d, deltaB %d, deltaW %d, "
"cost %7.2f\n", w_domain, deltaS[w_domain], deltaB[w_domain],
deltaW[w_domain], w_value);
#endif
}
if ((b_domain == ERR) && (w_domain == ERR)) goto INNER_LOOP_END;
if (b_value + EPS < w_value)
{ domain = b_domain; value = b_value;
removeBucket(b_bucket, domain);
}
else
{ domain = w_domain; value = w_value;
removeBucket(w_bucket, domain);
}
#ifdef DEBUG
printf(" domain %d removed from bucket\n", domain);
#endif
/* -------------------------------------------------------------------
flip the color of domain and put it in list of log. flipped domains
------------------------------------------------------------------- */
if (ftail != -1)
vtype[ftail] = -(domain+1); /* append domain */
else fhead = -(domain+1); /* list starts with domain */
vtype[domain] = 0; /* mark end of list */
ftail = domain; /* domain is last element in list */
if (tmp_color[domain] == BLACK)
{ tmp_color[domain] = WHITE;
updateB2W(w_bucket,b_bucket,dd,domain,tmp_color,deltaW,deltaB,deltaS);
}
else if (tmp_color[domain] == WHITE)
{ tmp_color[domain] = BLACK;
updateW2B(w_bucket,b_bucket,dd,domain,tmp_color,deltaW,deltaB,deltaS);
}
tmp_S += deltaS[domain];
tmp_B += deltaB[domain];
tmp_W += deltaW[domain];
pos++;
if (value + EPS < bestglobalvalue)
{ bestglobalvalue = value;
bestglobalpos = pos;
badflips = 0;
}
else badflips++;
if (badflips < MAX_BAD_FLIPS) goto INNER_LOOP_START;
INNER_LOOP_END:
/* --------------------------------------------
end of inner loop: now do the physical flips
-------------------------------------------- */
pos = 0;
nxtdomain = fhead;
while (nxtdomain != 0)
{ domain = -nxtdomain - 1;
if (pos < bestglobalpos)
{ if (color[domain] == BLACK) color[domain] = WHITE;
else color[domain] = BLACK;
cwght[GRAY] += deltaS[domain];
cwght[BLACK] += deltaB[domain];
cwght[WHITE] += deltaW[domain];
pos++;
}
nxtdomain = vtype[domain];
vtype[domain] = 1;
}
/* ----------------------------------------------
partition improved => re-start the whole stuff
---------------------------------------------- */
#ifdef DEBUG
printf(" INNER_LOOP_END (#pyhs. flips %d): S %d, B %d, W %d (%7.2f)\n",
bestglobalpos, cwght[GRAY], cwght[BLACK], cwght[WHITE],
bestglobalvalue);
waitkey();
#endif
/* JY: moved next instruction after the two
* freeBucket instructions because
* this was the cause of a memory leak.
* if (bestglobalpos > 0) goto OUTER_LOOP_START;
*/
freeBucket(b_bucket);
freeBucket(w_bucket);
if (bestglobalpos > 0) goto OUTER_LOOP_START;
free(tmp_color); free(deltaS); free(deltaB); free(deltaW);
}
void
eliminateStage(minprior_t *minprior, int istage, int scoretype, timings_t *cpus)
{ gelim_t *Gelim;
bucket_t *bucket;
stageinfo_t *stageinfo;
int *stage, *reachset, *auxbin, *auxtmp, *auxaux;
int *degree, *score;
int *pflag, nreach, nvtx, r, u, i;
Gelim = minprior->Gelim;
bucket = minprior->bucket;
stage = minprior->ms->stage;
stageinfo = minprior->stageinfo + istage;
reachset = minprior->reachset;
auxaux = minprior->auxaux;
auxbin = minprior->auxbin;
auxtmp = minprior->auxtmp;
pflag = &(minprior->flag);
nvtx = Gelim->G->nvtx;
degree = Gelim->degree;
score = Gelim->score;
#ifdef DEBUG
printf("\nSTARTING NEW ELIMINATION STAGE (nedges %d, maxedges %d)\n\n",
Gelim->G->nedges, Gelim->maxedges);
if (istage> 0) printElimGraph(Gelim);
/* waitkey(); */
#endif
/* -------------------------------------------------------------
load reachset with all principal variables in stage <= istage
------------------------------------------------------------- */
nreach = 0;
for (u = 0; u < nvtx; u++)
if ((score[u] == -1) && (stage[u] <= istage))
{ reachset[nreach++] = u;
score[u] = degree[u];
/* score[u] = degree[u]*(degree[u]-1)/2; */
}
/* ----------------------------------------------------------------
do an initial update of the vertices in reachset and fill bucket
---------------------------------------------------------------- */
starttimer(cpus[TIME_UPDSCORE]);
updateDegree(Gelim, reachset, nreach, auxbin);
updateScore(Gelim, reachset, nreach, scoretype, auxbin);
stoptimer(cpus[TIME_UPDSCORE]);
for (i = 0; i < nreach; i++)
{ u = reachset[i];
insertBucket(bucket, score[u], u);
}
/* -------------------------------------
and now start the elimination process
------------------------------------- */
while (TRUE)
{ if (eliminateStep(minprior, istage, scoretype) == 0)
break;
nreach = minprior->nreach;
#ifdef BE_CAUTIOUS
printf("checking arrays auxtmp and auxbin\n");
for (u = 0; u < nvtx; u++)
if ((auxtmp[u] >= *pflag) || (auxbin[u] != -1))
{ printf("ERROR: flag = %d, auxtmp[%d] = %d, auxbin[%d] = %d\n",
*pflag, u, auxtmp[u], u, auxbin[u]);
quit();
}
#endif
/* ----------------------------------------------------------
update the adjacency structure of all vertices in reachset
---------------------------------------------------------- */
starttimer(cpus[TIME_UPDADJNCY]);
updateAdjncy(Gelim, reachset, nreach, auxtmp, pflag);
stoptimer(cpus[TIME_UPDADJNCY]);
/* ----------------------------------------
find indistinguishable nodes in reachset
---------------------------------------- */
starttimer(cpus[TIME_FINDINODES]);
findIndNodes(Gelim, reachset, nreach, auxbin, auxaux, auxtmp, pflag);
stoptimer(cpus[TIME_FINDINODES]);
#ifdef BE_CAUTIOUS
printf("checking arrays auxtmp and auxbin\n");
for (u = 0; u < nvtx; u++)
if ((auxtmp[u] >= *pflag) || (auxbin[u] != -1))
{ printf("ERROR: flag = %d, auxtmp[%d] = %d, auxbin[%d] = %d\n",
*pflag, u, auxtmp[u], u, auxbin[u]);
quit();
}
#endif
/* ----------------------------------------------------------------
clean reachset of nonprincipal nodes and nodes not in this stage
---------------------------------------------------------------- */
r = 0;
for (i = 0; i < nreach; i++)
{ u = reachset[i];
if (score[u] >= 0)
reachset[r++] = u;
}
nreach = r;
/* ---------------------------------------------------
update the degree/score of all vertices in reachset
--------------------------------------------------- */
starttimer(cpus[TIME_UPDSCORE]);
updateDegree(Gelim, reachset, nreach, auxbin);
updateScore(Gelim, reachset, nreach, scoretype, auxbin);
stoptimer(cpus[TIME_UPDSCORE]);
/* ----------------------------
re-insert vertices in bucket
---------------------------- */
for (i = 0; i < nreach; i++)
{ u = reachset[i];
insertBucket(bucket, score[u], u);
}
stageinfo->nstep++;
}
}
void
updateW2B(bucket_t *w_bucket, bucket_t *b_bucket, domdec_t *dd, PORD_INT domain,
PORD_INT *tmp_color, PORD_INT *deltaW, PORD_INT *deltaB, PORD_INT *deltaS)
{ PORD_INT *xadj, *adjncy, *vwght, *vtype;
PORD_INT weight, u, v, i, istart, istop, j, jstart, jstop;
xadj = dd->G->xadj;
adjncy = dd->G->adjncy;
vwght = dd->G->vwght;
vtype = dd->vtype;
istart = xadj[domain];
istop = xadj[domain+1];
for (i = istart; i < istop; i++)
{ u = adjncy[i];
weight = vwght[u];
jstart = xadj[u];
jstop = xadj[u+1];
/* ---------------------------------------------------------------
subcase (1): before flipping domain to BLACK there was only one
other BLACK domain v. update deltaW[v] and deltaS[v]
--------------------------------------------------------------- */
if (deltaB[u] < 0)
{ v = -(deltaB[u]+1);
deltaB[u] = 1;
#ifdef DEBUG
printf(" W2B case (1): (via multisec %d) removing domain %d from "
"b_bucket\n", u, v);
#endif
removeBucket(b_bucket, v);
deltaW[v] -= weight; deltaS[v] += weight;
insertBucket(b_bucket, deltaS[v], v);
}
/* ---------------------------------------------------------------
subcase (2): all other domains are WHITE. update deltaW, deltaS
of these WHITE domains. NOTE: subcase (3) may directly follow
--------------------------------------------------------------- */
if (deltaB[u] == 0)
{ tmp_color[u] = GRAY;
for (j = jstart; j < jstop; j++)
{ v = adjncy[j];
if (vtype[v] == 1)
{
#ifdef DEBUG
printf(" W2B case (2): (via multisec %d) removing domain %d from "
"w_bucket\n", u, v);
#endif
removeBucket(w_bucket, v);
deltaW[v] += weight; deltaS[v] -= weight;
insertBucket(w_bucket, deltaS[v], v);
}
}
}
if (deltaW[u] < 0) deltaW[u] = 1; /* the unique WHITE dom. flipped */
deltaB[u]++; deltaW[u]--;
/* -------------------------------------------------------------
subcase (3): after flipping domain to BLACK there is only one
remaining WHITE domain. search it and update deltaB, deltaS
furthermore, store the remaining WHITE domain in deltaW[u]
------------------------------------------------------------- */
if (deltaW[u] == 1)
{ for (j = jstart; j < jstop; j++)
{ v = adjncy[j];
if ((tmp_color[v] == WHITE) && (vtype[v] == 1))
{
#ifdef DEBUG
printf(" W2B case (3): (via multisec %d) removing domain %d from "
"w_bucket\n", u, v);
#endif
removeBucket(w_bucket, v);
deltaB[v] += weight; deltaS[v] -= weight;
deltaW[u] = -(v+1);
insertBucket(w_bucket, deltaS[v], v);
}
}
}
/* ---------------------------------------------------------------
subcase (4): after flipping domain to BLACK there is no other
WHITE domain. update deltaB, deltaS of the BLACK domains
--------------------------------------------------------------- */
if (deltaW[u] == 0)
{ tmp_color[u] = BLACK;
for (j = jstart; j < jstop; j++)
{ v = adjncy[j];
if (vtype[v] == 1)
{
#ifdef DEBUG
printf(" W2B case (4): (via multisec %d) removing domain %d from "
"b_bucket\n", u, v);
#endif
removeBucket(b_bucket, v);
deltaB[v] -= weight; deltaS[v] += weight;
insertBucket(b_bucket, deltaS[v], v);
}
}
}
}
}
