#define DUMP_BEFORE 1
#define DUMP_AFTER 2
#define DUMP_CLOUD 4
+#define DUMP_ALL 2 * DUMP_CLOUD - 1
-static int dump_flags = 0;
+static int dump_flags = 0;
+static int subtree_iter = 4;
+static double constr_factor = 0.5;
/* Options using libcore */
#ifdef WITH_LIBCORE
{ "before", DUMP_BEFORE },
{ "after", DUMP_AFTER },
{ "cloud", DUMP_CLOUD },
- { "all", 2 * DUMP_CLOUD - 1 },
+ { "all", DUMP_ALL },
{ NULL, 0 }
};
};
static const lc_opt_table_entry_t options[] = {
- LC_OPT_ENT_ENUM_MASK("dump", "dump ifg before, after or after each cloud", &dump_var),
+ LC_OPT_ENT_ENUM_MASK("dump", "dump ifg before, after or after each cloud", &dump_var),
+ LC_OPT_ENT_INT ("iter", "iterations for subtree nodes (standard: 3)", &subtree_iter),
+ LC_OPT_ENT_DBL ("cf", "factor of constraint importance (between 0.0 and 1.0)", &constr_factor),
{ NULL }
};
col_t tmp_col;
col_t orig_col;
int last_color_change;
- unsigned fixed : 1;
- unsigned tmp_fixed : 1;
+ bitset_t *adm_cache;
+ unsigned fixed : 1;
+ unsigned tmp_fixed : 1;
+ unsigned is_constrained : 1;
struct list_head changed_list;
};
int *col_costs;
int costs;
int *fronts;
+ int *color_badness;
col_cost_pair_t *tmp_coloring;
struct list_head cloud_list;
struct list_head mst_list;
int inevit;
int best_costs;
int n_memb;
+ int n_constr;
int max_degree;
int ticks;
+ double freedom;
co2_cloud_irn_t *master;
co2_cloud_irn_t *mst_root;
co2_cloud_irn_t **seq;
return ci;
}
+#define CLOUD_WEIGHT(c) ((1 - constr_factor) * (c)->costs + constr_factor * (c)->freedom)
static int cmp_clouds_gt(const void *a, const void *b)
{
const co2_cloud_t **p = a;
const co2_cloud_t **q = b;
- int c = (*p)->costs;
- int d = (*q)->costs;
- return CMP(d, c);
+ double c = CLOUD_WEIGHT(*p);
+ double d = CLOUD_WEIGHT(*q);
+ return QSORT_CMP(d, c);
}
/**
const col_cost_pair_t *q = b;
int c = p->costs;
int d = q->costs;
- return CMP(c, d);
+ return QSORT_CMP(c, d);
}
static col_t get_col(co2_t *env, ir_node *irn)
return ci->fixed || ci->tmp_fixed;
}
-static bitset_t *admissible_colors(co2_t *env, co2_irn_t *ci, bitset_t *bs)
+static INLINE bitset_t *get_adm(co2_t *env, co2_irn_t *ci)
{
- arch_register_req_t req;
-
- arch_get_register_req(env->co->aenv, &req, ci->irn, BE_OUT_POS(0));
- if(arch_register_req_is(&req, limited))
- req.limited(req.limited_env, bs);
- else {
- bitset_copy(bs, env->ignore_regs);
- bitset_flip_all(bs);
+ if(!ci->adm_cache) {
+ arch_register_req_t req;
+ ci->adm_cache = bitset_obstack_alloc(phase_obst(&env->ph), env->n_regs);
+ arch_get_register_req(env->co->aenv, &req, ci->irn, BE_OUT_POS(0));
+ if(arch_register_req_is(&req, limited)) {
+ req.limited(req.limited_env, ci->adm_cache);
+ ci->is_constrained = 1;
+ }
+ else {
+ bitset_copy(ci->adm_cache, env->ignore_regs);
+ bitset_flip_all(ci->adm_cache);
+ }
}
+ return ci->adm_cache;
+}
+
+static INLINE bitset_t *admissible_colors(co2_t *env, co2_irn_t *ci, bitset_t *bs)
+{
+ bitset_copy(bs, get_adm(env, ci));
return bs;
}
-static int is_color_admissible(co2_t *env, co2_irn_t *ci, col_t col)
+static INLINE int is_color_admissible(co2_t *env, co2_irn_t *ci, col_t col)
{
- bitset_t *bs = bitset_alloca(env->co->cls->n_regs);
- admissible_colors(env, ci, bs);
+ bitset_t *bs = get_adm(env, ci);
return bitset_is_set(bs, col);
}
+static INLINE int is_constrained(co2_t *env, co2_irn_t *ci)
+{
+ if(!ci->adm_cache)
+ get_adm(env, ci);
+ return ci->is_constrained;
+}
+
static void incur_constraint_costs(co2_t *env, ir_node *irn, col_cost_pair_t *col_costs, int costs)
{
bitset_t *aux = bitset_alloca(env->co->cls->n_regs);
be_ifg_t *ifg = env->co->cenv->ifg;
int n_regs = env->co->cls->n_regs;
bitset_t *forb = bitset_alloca(n_regs);
- affinity_node_t *a = get_affinity_info(env->co, irn);
+ affinity_node_t *a = ci->aff;
bitset_pos_t elm;
ir_node *pos;
col_costs[col].costs = add_saturated(col_costs[col].costs, 8 * be_ifg_degree(ifg, pos));
}
}
+ be_ifg_neighbours_break(ifg, it);
/* Set the costs to infinity for each color which is not allowed at this node. */
bitset_foreach(forb, elm) {
}
-static void single_color_cost(co2_t *env, col_t col, col_cost_pair_t *seq)
+static void single_color_cost(co2_t *env, co2_irn_t *ci, col_t col, col_cost_pair_t *seq)
{
int n_regs = env->co->cls->n_regs;
int i;
seq[i].costs = INT_MAX;
}
+ assert(is_color_admissible(env, ci, col));
seq[col].col = 0;
seq[0].col = col;
seq[0].costs = 0;
break;
}
}
+ be_ifg_neighbours_break(ifg, it);
/*
We managed to assign the target color to all neighbors, so from the perspective
list_add(&ci->changed_list, parent_changed);
}
- DB((env->dbg, LEVEL_3, "\t\t%2{firm:indent}ok\n", depth));
- return 1;
+ res = 1;
+ goto end;
}
- if(!color_is_fix(env, irn)) {
+ if(!color_is_fix(env, irn) && is_color_admissible(env, ci, tgt_col)) {
int n_regs = env->co->cls->n_regs;
col_cost_pair_t *seq = alloca(n_regs * sizeof(seq[0]));
/* Get the costs for giving the node a specific color. */
- single_color_cost(env, tgt_col, seq);
+ single_color_cost(env, ci, tgt_col, seq);
/* Try recoloring the node using the color list. */
res = recolor(env, irn, seq, parent_changed, depth);
- DB((env->dbg, LEVEL_3, "\t\t%2{firm:indent}color %d %s for %+F\n", depth, tgt_col, res ? "was ok" : "failed", irn));
}
+end:
+ DB((env->dbg, LEVEL_3, "\t\t%2{firm:indent}color %d %s for %+F\n", depth, tgt_col, res ? "was ok" : "failed", irn));
return res;
}
{
const edge_t *p = a;
const edge_t *q = b;
- return CMP(p->costs, q->costs);
+ return QSORT_CMP(q->costs, p->costs);
}
static co2_cloud_irn_t *find_mst_root(co2_cloud_irn_t *ci)
{
- while(ci->mst_parent != ci->mst_parent)
+ while(ci != ci->mst_parent)
ci = ci->mst_parent;
return ci;
}
{
const co2_cloud_irn_t *p = a;
const co2_cloud_irn_t *q = b;
- return CMP(q->mst_costs, p->mst_costs);
+ return QSORT_CMP(q->mst_costs, p->mst_costs);
}
static void fill_tmp_coloring(co2_cloud_irn_t *ci, col_t col)
static int cloud_mst_build_colorings(co2_cloud_irn_t *ci, int depth)
{
- co2_t *env = ci->cloud->env;
- int n_regs = env->n_regs;
- col_cost_pair_t *seq = alloca(n_regs * sizeof(seq[0]));
- int *front = alloca(ci->mst_n_childs * sizeof(front[0]));
- int best_col = -1;
- int best_cost = INT_MAX;
+ co2_t *env = ci->cloud->env;
+ int n_regs = env->n_regs;
+ col_cost_pair_t *seq = alloca(n_regs * sizeof(seq[0]));
+ int *front = alloca(ci->mst_n_childs * sizeof(front[0]));
+ int best_col = -1;
+ int best_cost = INT_MAX;
int i;
return best_col;
}
+static void node_color_badness(co2_cloud_irn_t *ci, int *badness)
+{
+ co2_t *env = ci->cloud->env;
+ co2_irn_t *ir = &ci->inh;
+ int n_regs = env->n_regs;
+ be_ifg_t *ifg = env->co->cenv->ifg;
+ bitset_t *bs = bitset_alloca(n_regs);
+
+ bitset_pos_t elm;
+ ir_node *irn;
+ void *it;
+
+ admissible_colors(env, &ci->inh, bs);
+ bitset_flip_all(bs);
+ bitset_foreach(bs, elm)
+ badness[elm] = ci->costs;
+
+ /* Use constrained/fixed interfering neighbors to influence the color badness */
+ it = be_ifg_neighbours_iter_alloca(ifg);
+ be_ifg_foreach_neighbour(ifg, it, ir->irn, irn) {
+ co2_irn_t *ni = get_co2_irn(env, irn);
+
+ admissible_colors(env, ni, bs);
+ if(bitset_popcnt(bs) == 1) {
+ bitset_pos_t c = bitset_next_set(bs, 0);
+ badness[c] += ci->costs;
+ }
+
+ else if(ni->fixed) {
+ col_t c = get_col(env, ni->irn);
+ badness[c] += ci->costs;
+ }
+ }
+ be_ifg_neighbours_break(ifg, it);
+
+}
+
+static int cloud_color_badness(co2_cloud_t *cloud)
+{
+ int *badness = alloca(cloud->env->n_regs * sizeof(badness[0]));
+ int i;
+
+ memset(badness, 0, cloud->env->n_regs * sizeof(badness[0]));
+ for(i = 0; i < cloud->n_memb; ++i)
+ node_color_badness(cloud->seq[i], badness);
+}
+
+static void determine_color_badness(co2_cloud_irn_t *ci, int depth)
+{
+ co2_t *env = ci->cloud->env;
+ int i, j;
+
+ node_color_badness(ci, ci->color_badness);
+
+ /* Collect the color badness for the whole subtree */
+ for(i = 0; i < ci->mst_n_childs; ++i) {
+ co2_cloud_irn_t *child = ci->mst_childs[i];
+ determine_color_badness(child, depth + 1);
+
+ for(j = 0; j < env->n_regs; ++j)
+ ci->color_badness[j] += child->color_badness[j];
+ }
+
+ for(j = 0; j < env->n_regs; ++j)
+ DBG((env->dbg, LEVEL_2, "%2{firm:indent}%+F col %d badness %d\n", depth, ci->inh.irn, j, ci->color_badness[j]));
+}
+
+static void unfix_subtree(co2_cloud_irn_t *ci)
+{
+ int i;
+
+ ci->inh.fixed = 0;
+ for(i = 0; i < ci->mst_n_childs; ++i)
+ unfix_subtree(ci->mst_childs[i]);
+}
+
+static int coalesce_top_down(co2_cloud_irn_t *ci, int child_nr, int depth)
+{
+ co2_t *env = ci->cloud->env;
+ col_cost_pair_t *seq = alloca(env->n_regs * sizeof(seq[0]));
+ int is_root = ci->mst_parent == ci;
+ col_t parent_col = is_root ? -1 : get_col(env, ci->mst_parent->inh.irn);
+ int min_badness = INT_MAX;
+ int best_col_costs = INT_MAX;
+ int best_col = -1;
+ int n_regs = env->n_regs;
+ int n_iter = is_root ? MIN(n_regs, subtree_iter) : 1;
+
+ struct list_head changed;
+ int ok, i, j;
+
+ for(i = 0; i < n_regs; ++i) {
+ int badness = ci->color_badness[i];
+
+ seq[i].col = i;
+ seq[i].costs = is_color_admissible(env, &ci->inh, i) ? badness : INT_MAX;
+
+ min_badness = MIN(min_badness, badness);
+ }
+
+ /* If we are not the root and the parent's color is allowed for this node give it top prio. */
+ if(!is_root && is_color_admissible(env, &ci->inh, parent_col))
+ seq[parent_col].costs = min_badness - 1;
+
+ /* Sort the colors. The will be processed in that ordering. */
+ qsort(seq, env->n_regs, sizeof(seq[0]), col_cost_pair_lt);
+
+ DBG((env->dbg, LEVEL_2, "\t%2{firm:indent}starting top-down coalesce for %+F\n", depth, ci->inh.irn));
+ INIT_LIST_HEAD(&changed);
+ for(i = 0; i < (best_col < 0 ? n_regs : n_iter); ++i) {
+ col_t col = seq[i].col;
+ int costs = seq[i].costs;
+ int add_cost = !is_root && col != parent_col ? ci->mst_costs : 0;
+
+ int subtree_costs, sum_costs;
+
+ DBG((env->dbg, LEVEL_2, "\t%2{firm:indent}%+F trying color %d\n", depth, ci->inh.irn, col));
+
+ unfix_subtree(ci);
+ INIT_LIST_HEAD(&changed);
+ ok = change_color_single(env, ci->inh.irn, col, &changed, depth);
+ if(ok) {
+ materialize_coloring(&changed);
+ ci->inh.fixed = 1;
+ }
+
+ else
+ continue;
+
+ for(j = 0; j < ci->mst_n_childs; ++j) {
+ co2_cloud_irn_t *child = ci->mst_childs[j];
+ ok = coalesce_top_down(child, j, depth + 1) >= 0;
+ if(ok)
+ child->inh.fixed = 1;
+ else
+ break;
+ }
+
+ /* If the subtree could not be colored, we have to try another color. */
+ if(!ok)
+ continue;
+
+ subtree_costs = examine_subtree_coloring(ci, col);
+ sum_costs = subtree_costs + add_cost;
+ DBG((env->dbg, LEVEL_2, "\t%2{firm:indent}-> %+F costing %d + %d is ok.\n", depth, ci->inh.irn, subtree_costs, add_cost));
+
+ if(sum_costs < best_col_costs) {
+ best_col = col;
+ best_col_costs = sum_costs;
+ ci->col_costs[col] = subtree_costs;
+ }
+
+ if(sum_costs == 0)
+ break;
+
+ /* If we are at the root and we achieved an acceptable amount of optimization, we finish. */
+#if 0
+ if(is_root && (ci->cloud->inevit * stop_percentage < ci->cloud->inevit - sum_costs)) {
+ assert(best_col != -1);
+ break;
+ }
+#endif
+ }
+
+ if(!is_root) {
+ int *front = FRONT_BASE(ci->mst_parent, parent_col);
+ front[child_nr] = best_col;
+ }
+
+ return best_col;
+}
static void populate_cloud(co2_t *env, co2_cloud_t *cloud, affinity_node_t *a, int curr_costs)
{
int costs = 0;
neighb_t *n;
- if(ci->visited >= env->visited)
+ if(ci->cloud)
return;
/* mark the node as visited and add it to the cloud. */
- ci->visited = env->visited;
ci->cloud = cloud;
list_add(&ci->cloud_list, &cloud->members_head);
- DB((env->dbg, LEVEL_3, "\t%+F\n", ci->inh.irn));
+ DB((env->dbg, LEVEL_2, "\t%+F\n", ci->inh.irn));
/* determine the nodes costs */
co_gs_foreach_neighb(a, n) {
/* add the node's cost to the total costs of the cloud. */
ci->costs = costs;
cloud->costs += costs;
+ cloud->n_constr += is_constrained(env, &ci->inh);
+ cloud->freedom += bitset_popcnt(get_adm(env, &ci->inh));
cloud->max_degree = MAX(cloud->max_degree, ci->inh.aff->degree);
cloud->n_memb++;
cloud->env = env;
env->visited++;
populate_cloud(env, cloud, a, 0);
+ cloud->freedom = (cloud->n_memb * env->n_regs) / cloud->freedom;
/* Allocate space for the best colors array, where the best coloring is saved. */
// cloud->best_cols = phase_alloc(&env->ph, cloud->n_memb * sizeof(cloud->best_cols[0]));
ci->index = i;
cloud->seq[i++] = ci;
}
- DBG((env->dbg, LEVEL_2, "cloud cost %d\n", cloud->costs));
+ DBG((env->dbg, LEVEL_2, "cloud cost %d, freedom %f\n", cloud->costs, cloud->freedom));
return cloud;
}
-static void apply_coloring(co2_cloud_irn_t *ci, col_t col, struct list_head *changed, int depth)
+static void apply_coloring(co2_cloud_irn_t *ci, col_t col, int depth)
{
ir_node *irn = ci->inh.irn;
int *front = FRONT_BASE(ci, col);
int i, ok;
+ struct list_head changed;
+
+ INIT_LIST_HEAD(&changed);
DBG((ci->cloud->env->dbg, LEVEL_2, "%2{firm:indent}setting %+F to %d\n", depth, irn, col));
- ok = change_color_single(ci->cloud->env, irn, col, changed, depth);
+ ok = change_color_single(ci->cloud->env, irn, col, &changed, depth);
assert(ok && "Color changing may not fail while committing the coloring");
+ materialize_coloring(&changed);
- for(i = 0; i < ci->mst_n_childs; ++i) {
- apply_coloring(ci->mst_childs[i], front[i], changed, depth + 1);
+ for(i = 0; i < ci->mst_n_childs; ++i) {
+ apply_coloring(ci->mst_childs[i], front[i], depth + 1);
}
}
static void process_cloud(co2_cloud_t *cloud)
{
co2_t *env = cloud->env;
+ int n_regs = env->n_regs;
int n_edges = 0;
+ int *mst_edges = malloc(cloud->n_memb * cloud->n_memb * sizeof(mst_edges[0]));
+ pdeq *q;
struct list_head changed;
edge_t *edges;
int i;
int best_col;
+ memset(mst_edges, 0, cloud->n_memb * cloud->n_memb * sizeof(mst_edges[0]));
+
/* Collect all edges in the cloud on an obstack and sort the increasingly */
obstack_init(&cloud->obst);
for(i = 0; i < cloud->n_memb; ++i) {
DBG((env->dbg, LEVEL_2, "computing spanning tree of cloud with master %+F\n", cloud->master->inh.irn));
for(i = 0; i < n_edges; ++i) {
edge_t *e = &edges[i];
- co2_cloud_irn_t *p_src = find_mst_root(e->src);
- co2_cloud_irn_t *p_tgt = find_mst_root(e->tgt);
+ co2_cloud_irn_t *rs = find_mst_root(e->src);
+ co2_cloud_irn_t *rt = find_mst_root(e->tgt);
- if(p_src != p_tgt) {
- p_tgt->mst_n_childs++;
- p_src->mst_parent = p_tgt;
- p_src->mst_costs = e->costs;
+ /* if the union/find roots are different */
+ if(rs != rt) {
+ int si = e->src->index;
+ int ti = e->tgt->index;
- DBG((env->dbg, LEVEL_2, "\tadding edge %+F -- %+F cost %d\n", p_src->inh.irn, p_tgt->inh.irn, e->costs));
+ /* unify the sets */
+ rs->mst_parent = rt;
+ DBG((env->dbg, LEVEL_2, "\tadding edge %+F -- %+F cost %d\n", rs->inh.irn, rt->inh.irn, e->costs));
+
+ /* this edge is in the MST, so set it in the bitset. */
+ mst_edges[si * cloud->n_memb + ti] = e->costs;
+ mst_edges[ti * cloud->n_memb + si] = e->costs;
}
}
obstack_free(&cloud->obst, edges);
+ cloud->master->mst_parent = cloud->master;
+ cloud->mst_root = cloud->master;
+ q = new_pdeq1(cloud->master);
+ while(!pdeq_empty(q)) {
+ co2_cloud_irn_t *ci = pdeq_getl(q);
+ int ofs = ci->index * cloud->n_memb;
+ int end = ofs + cloud->n_memb;
+ int i;
+
+ ci->mst_n_childs = 0;
+ for(i = ofs; i < end; ++i) {
+ if(mst_edges[i] != 0) {
+ int other = i - ofs;
+ co2_cloud_irn_t *child = cloud->seq[i - ofs];
+
+ /* put the child to the worklist */
+ pdeq_putr(q, child);
+
+ /* make ci the parent of the child and add the child to the children array of the parent */
+ child->mst_parent = ci;
+ child->mst_costs = mst_edges[i];
+ ci->mst_n_childs++;
+ obstack_ptr_grow(&cloud->obst, child);
+
+ mst_edges[other * cloud->n_memb + ci->index] = 0;
+ mst_edges[i] = 0;
+ }
+ }
+
+ obstack_ptr_grow(&cloud->obst, NULL);
+ ci->mst_childs = obstack_finish(&cloud->obst);
+ }
+ del_pdeq(q);
+ free(mst_edges);
+
+
+ DBG((env->dbg, LEVEL_3, "mst:\n"));
for(i = 0; i < cloud->n_memb; ++i) {
co2_cloud_irn_t *ci = cloud->seq[i];
- ci->mst_childs = obstack_alloc(&cloud->obst, ci->mst_n_childs * sizeof(ci->mst_childs));
- ci->col_costs = obstack_alloc(&cloud->obst, env->n_regs * sizeof(ci->col_costs[0]));
- ci->tmp_coloring = obstack_alloc(&cloud->obst, env->n_regs * sizeof(ci->tmp_coloring[0]));
- ci->fronts = obstack_alloc(&cloud->obst, env->n_regs * ci->mst_n_childs * sizeof(ci->fronts[0]));
- memset(ci->col_costs, 0, env->n_regs * sizeof(ci->col_costs[0]));
- memset(ci->tmp_coloring, 0, env->n_regs * sizeof(ci->tmp_coloring[0]));
- memset(ci->fronts, 0, env->n_regs * ci->mst_n_childs * sizeof(ci->fronts[0]));
-
- ci->mst_n_childs = 0;
+ DBG((env->dbg, LEVEL_3, "\t%+F -> %+F\n", ci->inh.irn, ci->mst_parent->inh.irn));
}
- /* build the child arrays in the nodes */
for(i = 0; i < cloud->n_memb; ++i) {
co2_cloud_irn_t *ci = cloud->seq[i];
- if(ci->mst_parent != ci)
- ci->mst_parent->mst_childs[ci->mst_parent->mst_n_childs++] = ci;
- else {
- cloud->mst_root = ci;
- cloud->mst_costs = 0;
- }
- }
+ int n_childs = ci->mst_n_childs;
+ int j;
+
+ ci->col_costs = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->col_costs[0]));
+ ci->tmp_coloring = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->tmp_coloring[0]));
+ ci->fronts = obstack_alloc(&cloud->obst, n_regs * n_childs * sizeof(ci->fronts[0]));
+ ci->color_badness = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->fronts[0]));
+ memset(ci->color_badness, 0, n_regs * sizeof(ci->color_badness[0]));
+ memset(ci->col_costs, 0, n_regs * sizeof(ci->col_costs[0]));
+ memset(ci->tmp_coloring, 0, n_regs * sizeof(ci->tmp_coloring[0]));
+ memset(ci->fronts, 0, n_regs * n_childs * sizeof(ci->fronts[0]));
- /* Compute the "best" colorings. */
- best_col = cloud_mst_build_colorings(cloud->mst_root, 0);
+ for(j = 0; j < env->n_regs; j++)
+ ci->col_costs[j] = INT_MAX;
- for(i = 0; i < env->n_regs; ++i) {
- int c;
- c = examine_subtree_coloring(cloud->mst_root, i);
- DBG((env->dbg, LEVEL_2, "color %d costs %d\n", i, c));
}
- /* Apply the coloring for the best color in the root node and fix all nodes in this cloud */
- INIT_LIST_HEAD(&changed);
- apply_coloring(cloud->mst_root, best_col, &changed, 0);
- materialize_coloring(&changed);
+ determine_color_badness(cloud->mst_root, 0);
+ best_col = coalesce_top_down(cloud->mst_root, -1, 0);
+ unfix_subtree(cloud->mst_root);
+ apply_coloring(cloud->mst_root, best_col, 0);
+
+ /* The coloring should represent the one with the best costs. */
+ //materialize_coloring(&changed);
+ DBG((env->dbg, LEVEL_2, "\tbest coloring for root %+F was %d costing %d\n",
+ cloud->mst_root->inh.irn, best_col, examine_subtree_coloring(cloud->mst_root, best_col)));
+
+ /* Fix all nodes in the cloud. */
for(i = 0; i < cloud->n_memb; ++i)
cloud->seq[i]->inh.fixed = 1;
+ /* Free all space used while optimizing this cloud. */
obstack_free(&cloud->obst, NULL);
}
co2_irn_t *ci = get_co2_irn(env, irn);
int peri = 1;
+ char buf[128] = "";
+
if(ci->aff) {
co2_cloud_irn_t *cci = (void *) ci;
if (cci->cloud && cci->cloud->mst_root == cci)
peri = 2;
+
+ if(cci->cloud && cci->cloud->mst_root)
+ snprintf(buf, sizeof(buf), "%+F", cci->cloud->mst_root->inh.irn);
}
- ir_fprintf(f, "label=\"%+F\" style=filled peripheries=%d color=%s shape=%s", irn, peri,
+ ir_fprintf(f, "label=\"%+F%s\" style=filled peripheries=%d color=%s shape=%s", irn, buf, peri,
get_dot_color_name(get_col(env, irn)), get_dot_shape_name(env, ci));
}
co2_t *env = self;
affinity_node_t *a;
+#if 0
+ co2_cloud_t *pos;
+
+ list_for_each_entry(co2_cloud_t, pos, &env->cloud_head, list) {
+ int i;
+
+ for(i = 0; i < pos->n_memb - 1; ++i) {
+ fprintf(file, "\tn%d -- n%d [style=dotted color=green];\n", get_irn_idx(pos->seq[i]->inh.irn), get_irn_idx(pos->seq[i+1]->inh.irn));
+ }
+ }
+#endif
+
+
co_gs_foreach_aff_node(env->co, a) {
co2_cloud_irn_t *ai = get_co2_cloud_irn(env, a->irn);
int idx = get_irn_idx(a->irn);
neighb_t *n;
+ if(ai->mst_parent != ai)
+ fprintf(file, "\tn%d -- n%d [style=dotted color=blue arrowhead=normal];\n", idx, get_irn_idx(ai->mst_parent->inh.irn));
+
co_gs_foreach_neighb(a, n) {
int nidx = get_irn_idx(n->irn);
co2_cloud_irn_t *ci = get_co2_cloud_irn(env, n->irn);
void co_solve_heuristic_new(copy_opt_t *co)
{
+ char buf[256];
co2_t env;
FILE *f;
INIT_LIST_HEAD(&env.cloud_head);
if(dump_flags & DUMP_BEFORE) {
- if(f = be_chordal_open(co->cenv, "ifg_before_", "dot")) {
+ ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_before.dot", co->irg, co->cls->name);
+ if(f = fopen(buf, "wt")) {
be_ifg_dump_dot(co->cenv->ifg, co->irg, f, &ifg_dot_cb, &env);
fclose(f);
}
process(&env);
if(dump_flags & DUMP_AFTER) {
- if(f = be_chordal_open(co->cenv, "ifg_after_", "dot")) {
+ ir_snprintf(buf, sizeof(buf), "ifg_%F_%s_after.dot", co->irg, co->cls->name);
+ if(f = fopen(buf, "wt")) {
be_ifg_dump_dot(co->cenv->ifg, co->irg, f, &ifg_dot_cb, &env);
fclose(f);
}