void freeBucketR(struct bucket **ppBkt){
if (ppBkt == NULL) return;
if (*ppBkt == NULL) return;
/* Go down list */
freeBucketR( &((*ppBkt)->pNext) );
/* At this point, pnext is freed and null. So free this bucket */
freeBucket(ppBkt);
}
void
freeMinPriority(minprior_t *minprior)
{
freeElimGraph(minprior->Gelim);
freeBucket(minprior->bucket);
free(minprior->stageinfo);
free(minprior->reachset);
free(minprior->auxaux);
free(minprior->auxbin);
free(minprior->auxtmp);
free(minprior);
}
/* tests for bucket accessing */
int testBucketAccessing() {
Bucket * first = firstTestBucket();
Bucket * second = secondTestBucket();
Bucket * third = thirdTestBucket();
int passing = 1;
/* set up the list */
first->next = second;
second->next = third;
/* test the accessor for the first one */
if (bucketGet(first, "thing") != first) {
passing = 0;
fprintf(stderr, "bucket did not free successfully\n");
}
freeBucket(first);
freeBucket(second);
freeBucket(third);
return passing;
}
/* test for creation and destruction */
int bucketCreationTests() {
int passing = 1;
char * test_key = "thing";
char * test_value = "This is a string";
/* bucket test variables */
Bucket * test_bucket = NULL;
/* test the bucket constructor */
if (passing) {
test_bucket = firstTestBucket();
/* check the values */
if (strncmp(test_bucket->key, test_key, test_bucket->key_length)) {
passing = 0;
fprintf(stderr, "bucket key is incorrect: '%s', expected '%s'\n",
test_bucket->key, test_key);
}
/* check the values */
if (strncmp((char *)test_bucket->value, test_value, strlen(test_value))) {
passing = 0;
fprintf(stderr, "bucket value is incorrect: '%s', expected '%s'\n",
(char *)test_bucket->value, test_value);
}
if (passing) {
printf("bucket constructed successfully\n");
}
}
/* check free */
if (passing) {
test_bucket = freeBucket(test_bucket);
if (test_bucket) {
passing = 0;
fprintf(stderr, "bucket did not free successfully\n");
}
if (passing) {
printf("bucket freed successfully\n");
}
}
return passing;
}
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);
}
