int
mnode_find (const AFSFid *fid, struct mnode **node)
{
struct mnode ptr, *res = NULL;
ptr.fid = *fid;
while (res == NULL) {
res = hashtabsearch (mnode_htab, &ptr);
if (res) {
if (res->flags.removedp == TRUE)
return ENOENT;
if (res->li)
listdel (mnode_lru, res->li);
if (res->ref == 0)
mnode_numfree--;
res->ref++;
} else if (mnode_numfree != 0) {
res = listdeltail (mnode_lru); assert (res);
assert (res->ref == 0);
hashtabdel (mnode_htab, res);
reset_node (res, fid);
hashtabadd (mnode_htab, res);
res->ref++;
} else {
/* XXX */
mlog_log (MDEBWARN,
"mnode_find: no free nodes, had to malloc()");
res = malloc(sizeof(struct mnode));
if (res == NULL) {
mlog_log (MDEBWARN,
"mnode_find: malloc() failed");
LWP_DispatchProcess(); /* Yield */
continue;
}
reset_node (res, fid);
hashtabadd (mnode_htab, res);
res->ref++;
}
}
assert(res->flags.removedp == FALSE);
*node = res;
res->li = listaddhead (mnode_lru, *node);
return 0;
}
static void
reset_fnode_counters (st_parameter_dt *dtp)
{
fnode *f;
format_data *fmt;
fmt = dtp->u.p.fmt;
/* Clear this pointer at the head so things start at the right place. */
fmt->array.array[0].current = NULL;
for (f = fmt->array.array[0].u.child; f; f = f->next)
reset_node (f);
}
// chaitin's algorithm
void color_graph(graph* g, int n) {
if (g == NULL) return;
if (g->vertices == NULL) return;
int size = g->size;
int spilled = 0; // number of nodes not considered
// simplify graph
int simplified; // did we simplify the graph on this iteration?
vertex* node;
while (spilled < g->size) {
// remove all nodes with degree < n
do {
simplified = 0;
for (node = g->vertices; node != NULL; node = node->next) {
if ((node->removed == 0) && (node->num_edges < n)) {
remove_node(node);
// push it onto the stack for coloring
size--;
push(node);
simplified = 1;
}
}//for
} while ((size != 0) && (simplified == 1));
// spill if we can't color this
if (size == 0) {
break;
} else {
empty_stack();
spill(g);
spilled++;
size = g->size - spilled;
}
}
// color in reverse order of removal
int i;
while (!is_stack_empty()) {
node = pop();
reset_node(node);
// use first available color
for (i = 0; i < n; i++) {
if (valid_node_color(node, i)) {
node->color = i;
break;
}
}//for
}
}
static void
reset_node (fnode *fn)
{
fnode *f;
fn->count = 0;
fn->current = NULL;
if (fn->format != FMT_LPAREN)
return;
for (f = fn->u.child; f; f = f->next)
{
if (f->format == FMT_RPAREN)
break;
reset_node (f);
}
}
/**
* Allocate a new node in the shared memory segment
*
* Implementation: look to see if we can re-use any old node objects.
* If not, allocate at location pointed to by mem->next_free and increment it accordingly
*/
node *create_new_node(memory_layout* mem) {
node *loc = NULL;
if(mem->open_nodes != NULL) {
loc = mem->open_nodes;
mem->open_nodes = mem->open_nodes->next;
}
else {
loc = (node *) mem->next_free;
mem->next_free += sizeof(node);
if(mem->next_free > shared_memory + SHARED_MEM_SIZE) {
return NULL;
}
}
reset_node(loc);
return loc;
}
/**
* "Free" the given node, or reset it and add it to the list of available nodes.
*/
void free_node(memory_layout *mem, node *cur) {
reset_node(cur);
cur->next = mem->open_nodes;
mem->open_nodes = cur;
}
