X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur4.c;h=e364ad5388b9b4f08fc5f5b6641f019c54d8f40a;hb=1b7ade9fe95204550ee3ba99e9f9ea6c7d238dd9;hp=42bdee7a10e480f7a84a8f565b0b1948071705a8;hpb=0e5f781d021c0b1e20ba08f583d4971419fedb5d;p=libfirm

diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c
index 42bdee7a1..e364ad538 100644
--- a/ir/be/becopyheur4.c
+++ b/ir/be/becopyheur4.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -78,13 +78,16 @@ static firm_dbg_module_t *dbg = NULL;
 
 #endif
 
-static int last_chunk_id        = 0;
+typedef float real_t;
+#define REAL(C)   (C ## f)
+
+static unsigned last_chunk_id   = 0;
 static int recolor_limit        = 4;
-static double dislike_influence = 0.1;
+static real_t dislike_influence = REAL(0.1);
 
 typedef struct _col_cost_t {
-	int    col;
-	double cost;
+	int     col;
+	real_t  cost;
 } col_cost_t;
 
 /**
@@ -92,14 +95,13 @@ typedef struct _col_cost_t {
  */
 typedef struct _aff_chunk_t {
 	const ir_node    **n;                   /**< An ARR_F containing all nodes of the chunk. */
-	bitset_t         *nodes;                /**< A bitset containing all nodes inside this chunk. */
-	bitset_t         *interfere;            /**< A bitset containing all interfering neighbours of the nodes in this chunk. */
+	const ir_node  **interfere;             /**< An ARR_F containing all inference. */
 	int              weight;                /**< Weight of this chunk */
 	unsigned         weight_consistent : 1; /**< Set if the weight is consistent. */
-	unsigned         deleted           : 1; /**< Set if the was deleted. */
-	int              id;                    /**< For debugging: An id of this chunk. */
-	int              visited;
-	col_cost_t       *color_affinity;
+	unsigned         deleted           : 1; /**< For debugging: Set if the was deleted. */
+	unsigned         id;                    /**< An id of this chunk. */
+	unsigned         visited;
+	col_cost_t       color_affinity[1];
 } aff_chunk_t;
 
 /**
@@ -108,7 +110,7 @@ typedef struct _aff_chunk_t {
 typedef struct _aff_edge_t {
 	const ir_node *src;                   /**< Source node. */
 	const ir_node *tgt;                   /**< Target node. */
-	double  weight;                 /**< The weight of this edge. */
+	int           weight;                 /**< The weight of this edge. */
 } aff_edge_t;
 
 /* main coalescing environment */
@@ -122,7 +124,7 @@ typedef struct _co_mst_env_t {
 	be_ifg_t         *ifg;           /**< the interference graph */
 	const arch_env_t *aenv;          /**< the arch environment */
 	copy_opt_t       *co;            /**< the copy opt object */
-	int               chunk_visited;
+	unsigned         chunk_visited;
 	col_cost_t      **single_cols;
 } co_mst_env_t;
 
@@ -139,7 +141,7 @@ typedef struct _co_mst_irn_t {
 	int              tmp_col;           /**< a temporary assigned color */
 	unsigned         fixed     : 1;     /**< the color is fixed */
 	struct list_head list;              /**< Queue for coloring undo. */
-	double           constr_factor;
+	real_t           constr_factor;
 } co_mst_irn_t;
 
 #define get_co_mst_irn(mst_env, irn) (phase_get_or_set_irn_data(&(mst_env)->ph, (irn)))
@@ -152,12 +154,13 @@ typedef int decide_func_t(const co_mst_irn_t *node, int col);
  * Write a chunk to stderr for debugging.
  */
 static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c) {
-	bitset_pos_t idx;
+	int i, l;
+	(void) env;
 	if (c->weight_consistent)
 		ir_fprintf(stderr, " $%d ", c->weight);
 	ir_fprintf(stderr, "{");
-	bitset_foreach(c->nodes, idx) {
-		ir_node *n = get_idx_irn(env->co->irg, idx);
+	for (i = 0, l = ARR_LEN(c->n); i < l; ++i) {
+		const ir_node *n = c->n[i];
 		ir_fprintf(stderr, " %+F,", n);
 	}
 	ir_fprintf(stderr, "}");
@@ -173,8 +176,9 @@ static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *n
 	if (bitset_popcnt(node->adm_colors) < 1)
 		fprintf(stderr, "no admissible colors?!?");
 	else {
-		bitset_foreach(node->adm_colors, idx)
+		bitset_foreach(node->adm_colors, idx) {
 			fprintf(stderr, " %d", idx);
+		}
 	}
 }
 
@@ -235,14 +239,14 @@ static int cmp_aff_edge(const void *a, const void *b) {
 static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b) {
 	const col_cost_t *c1 = a;
 	const col_cost_t *c2 = b;
-	double diff = c1->cost - c2->cost;
+	real_t diff = c1->cost - c2->cost;
 	return (diff > 0) - (diff < 0);
 }
 
 static int cmp_col_cost_gt(const void *a, const void *b) {
 	const col_cost_t *c1 = a;
 	const col_cost_t *c2 = b;
-	double diff = c2->cost - c1->cost;
+	real_t diff = c2->cost - c1->cost;
 	return (diff > 0) - (diff < 0);
 }
 
@@ -250,14 +254,13 @@ static int cmp_col_cost_gt(const void *a, const void *b) {
  * Creates a new affinity chunk
  */
 static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
-	aff_chunk_t *c = xmalloc(sizeof(*c));
+	aff_chunk_t *c = xmalloc(sizeof(*c) + (env->n_regs - 1) * sizeof(c->color_affinity[0]));
+	c->n                 = NEW_ARR_F(const ir_node *, 0);
+	c->interfere         = NEW_ARR_F(const ir_node *, 0);
 	c->weight            = -1;
 	c->weight_consistent = 0;
-	c->n                 = NEW_ARR_F(const ir_node *, 0);
-	c->nodes             = bitset_irg_malloc(env->co->irg);
-	c->interfere         = bitset_irg_malloc(env->co->irg);
-	c->color_affinity    = xmalloc(env->n_regs * sizeof(c->color_affinity[0]));
-	c->id                = last_chunk_id++;
+	c->deleted           = 0;
+	c->id                = ++last_chunk_id;
 	c->visited           = 0;
 	pset_insert(env->chunkset, c, c->id);
 	return c;
@@ -268,32 +271,82 @@ static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
  */
 static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	pset_remove(env->chunkset, c, c->id);
-	bitset_free(c->nodes);
-	bitset_free(c->interfere);
-	xfree(c->color_affinity);
+	DEL_ARR_F(c->interfere);
 	DEL_ARR_F(c->n);
 	c->deleted = 1;
 	free(c);
 }
 
+/**
+ * binary search of sorted nodes.
+ *
+ * @return the position where n is found in the array arr or ~pos
+ * if the nodes is not here.
+ */
+static INLINE int nodes_bsearch(const ir_node **arr, const ir_node *n) {
+	int hi = ARR_LEN(arr);
+	int lo = 0;
+
+	while (lo < hi) {
+		int md = lo + ((hi - lo) >> 1);
+
+		if (arr[md] == n)
+			return md;
+		if (arr[md] < n)
+			lo = md + 1;
+		else
+			hi = md;
+	}
+
+	return ~lo;
+}
+
+/** Check if a node n can be found inside arr. */
+static int node_contains(const ir_node **arr, const ir_node *n) {
+	int i = nodes_bsearch(arr, n);
+	return i >= 0;
+}
+
+/**
+ * Insert a node into the sorted nodes list.
+ *
+ * @return 1 if the node was inserted, 0 else
+ */
+static int nodes_insert(const ir_node ***arr, const ir_node *irn) {
+	int idx = nodes_bsearch(*arr, irn);
+
+	if (idx < 0) {
+		int i, n = ARR_LEN(*arr);
+		const ir_node **l;
+
+		ARR_APP1(const ir_node *, *arr, irn);
+
+		/* move it */
+		idx = ~idx;
+		l = *arr;
+		for (i = n - 1; i >= idx; --i)
+			l[i + 1] = l[i];
+		l[idx] = irn;
+		return 1;
+	}
+	return 0;
+}
+
 /**
  * Adds a node to an affinity chunk
  */
 static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
 	int i;
 
-	if (bitset_is_set(c->nodes, get_irn_idx(node->irn)))
+	if (! nodes_insert(&c->n, node->irn))
 		return;
 
 	c->weight_consistent = 0;
 	node->chunk          = c;
-	bitset_set(c->nodes, get_irn_idx(node->irn));
-
-	ARR_APP1(ir_node *, c->n, node->irn);
 
 	for (i = node->n_neighs - 1; i >= 0; --i) {
 		ir_node *neigh = node->int_neighs[i];
-		bitset_set(c->interfere, get_irn_idx(neigh));
+		nodes_insert(&c->interfere, neigh);
 	}
 }
 
@@ -336,7 +389,7 @@ static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn, void *old) {
 		bitset_andnot(res->adm_colors, env->ignore_regs);
 
 		/* compute the constraint factor */
-		res->constr_factor = (double) (1 + env->n_regs - bitset_popcnt(res->adm_colors)) / env->n_regs;
+		res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcnt(res->adm_colors)) / env->n_regs;
 
 		/* set the number of interfering affinity neighbours to -1, they are calculated later */
 		res->int_aff_neigh = -1;
@@ -358,25 +411,30 @@ static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn, void *old) {
 /**
  * Check if affinity chunk @p chunk interferes with node @p irn.
  */
-static INLINE int aff_chunk_interferes(co_mst_env_t *env, const aff_chunk_t *chunk, const ir_node *irn) {
-	(void) env;
-	return bitset_is_set(chunk->interfere, get_irn_idx(irn));
+static INLINE int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *irn) {
+	return node_contains(chunk->interfere, irn);
 }
 
 /**
  * Check if there are interference edges from c1 to c2.
- * @param env   The global co_mst environment
  * @param c1    A chunk
  * @param c2    Another chunk
  * @return 1 if there are interferences between nodes of c1 and c2, 0 otherwise.
  */
-static INLINE int aff_chunks_interfere(co_mst_env_t *env, const aff_chunk_t *c1, const aff_chunk_t *c2) {
-	(void) env;
+static INLINE int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2) {
+	int i;
+
 	if (c1 == c2)
 		return 0;
 
 	/* check if there is a node in c2 having an interfering neighbor in c1 */
-	return bitset_intersect(c1->interfere, c2->nodes);
+	for (i = ARR_LEN(c2->n) - 1; i >= 0; --i) {
+		const ir_node *irn = c2->n[i];
+
+		if (node_contains(c1->interfere, irn))
+			return 1;
+	}
+	return 0;
 }
 
 /**
@@ -398,13 +456,13 @@ static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node
 	aff_chunk_t *c2 = get_aff_chunk(env, tgt);
 
 #ifdef DEBUG_libfirm
-		DB((dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1 ? c1->id : -1));
+		DB((dbg, LEVEL_4, "Attempt to let c1 (id %u): ", c1 ? c1->id : -1));
 		if (c1) {
 			DBG_AFF_CHUNK(env, LEVEL_4, c1);
 		} else {
 			DB((dbg, LEVEL_4, "{%+F}", src));
 		}
-		DB((dbg, LEVEL_4, "\n\tabsorb c2 (id %d): ", c2 ? c2->id : -1));
+		DB((dbg, LEVEL_4, "\n\tabsorb c2 (id %u): ", c2 ? c2->id : -1));
 		if (c2) {
 			DBG_AFF_CHUNK(env, LEVEL_4, c2);
 		} else {
@@ -432,24 +490,28 @@ static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node
 			}
 		} else {
 			/* c2 already exists */
-			if (! aff_chunk_interferes(env, c2, src)) {
+			if (! aff_chunk_interferes(c2, src)) {
 				aff_chunk_add_node(c2, get_co_mst_irn(env, src));
 				goto absorbed;
 			}
 		}
 	} else if (c2 == NULL) {
 		/* c1 already exists */
-		if (! aff_chunk_interferes(env, c1, tgt)) {
+		if (! aff_chunk_interferes(c1, tgt)) {
 			aff_chunk_add_node(c1, get_co_mst_irn(env, tgt));
 			goto absorbed;
 		}
-	} else if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
+	} else if (c1 != c2 && ! aff_chunks_interfere(c1, c2)) {
 		int idx, len;
 
 		for (idx = 0, len = ARR_LEN(c2->n); idx < len; ++idx)
 			aff_chunk_add_node(c1, get_co_mst_irn(env, c2->n[idx]));
 
-		bitset_or(c1->interfere, c2->interfere);
+		for (idx = 0, len = ARR_LEN(c2->interfere); idx < len; ++idx) {
+			const ir_node *irn = c2->interfere[idx];
+			nodes_insert(&c1->interfere, irn);
+		}
+
 		c1->weight_consistent = 0;
 
 		delete_aff_chunk(env, c2);
@@ -473,7 +535,7 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
 
 		for (i = 0; i < env->n_regs; ++i) {
 			c->color_affinity[i].col = i;
-			c->color_affinity[i].cost = 0.0;
+			c->color_affinity[i].cost = REAL(0.0);
 		}
 
 		for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
@@ -482,7 +544,7 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
 			co_mst_irn_t          *node    = get_co_mst_irn(env, n);
 
 			node->chunk = c;
-			if (node->constr_factor > 0.0) {
+			if (node->constr_factor > REAL(0.0)) {
 				bitset_pos_t col;
 				bitset_foreach (node->adm_colors, col)
 					c->color_affinity[col].cost += node->constr_factor;
@@ -492,19 +554,18 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
 				neighb_t *neigh;
 				co_gs_foreach_neighb(an, neigh) {
 					const ir_node *m    = neigh->irn;
-					const int     m_idx = get_irn_idx(m);
 
 					/* skip ignore nodes */
 					if (arch_irn_is(env->aenv, m, ignore))
 						continue;
 
-					w += bitset_is_set(c->nodes, m_idx) ? neigh->costs : 0;
+					w += node_contains(c->n, m) ? neigh->costs : 0;
 				}
 			}
 		}
 
 		for (i = 0; i < env->n_regs; ++i)
-			c->color_affinity[i].cost *= (1.0 / ARR_LEN(c->n));
+			c->color_affinity[i].cost *= (REAL(1.0) / ARR_LEN(c->n));
 
 		c->weight            = w;
 		// c->weight            = bitset_popcnt(c->nodes);
@@ -620,12 +681,13 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 	foreach_pset(env->chunkset, curr_chunk) {
 		aff_chunk_assure_weight(env, curr_chunk);
 
-		DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
+		DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id));
 		DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
 		DBG((dbg, LEVEL_1, "\n"));
 
 		pqueue_put(env->chunks, curr_chunk, curr_chunk->weight);
 	}
+
 	foreach_phase_irn(&env->ph, n) {
 		co_mst_irn_t *mirn = get_co_mst_irn(env, n);
 
@@ -636,7 +698,7 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 
 			aff_chunk_assure_weight(env, curr_chunk);
 
-			DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
+			DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id));
 			DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
 			DBG((dbg, LEVEL_1, "\n"));
 
@@ -720,7 +782,7 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
 {
 	waitq *nodes = new_waitq();
 
-	DBG((dbg, LEVEL_1, "\n\tExpanding new chunk (#%d) from %+F, color %d:", chunk->id, node->irn, col));
+	DBG((dbg, LEVEL_1, "\n\tExpanding new chunk (#%u) from %+F, color %d:", chunk->id, node->irn, col));
 
 	/* init queue and chunk */
 	waitq_put(nodes, node);
@@ -747,11 +809,11 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
 
 				n2 = get_co_mst_irn(env, m);
 
-				if (! bitset_is_set(visited, m_idx)       &&
-					decider(n2, col)                      &&
-					! n2->fixed                           &&
-					! aff_chunk_interferes(env, chunk, m) &&
-					bitset_is_set(orig_chunk->nodes, m_idx))
+				if (! bitset_is_set(visited, m_idx)  &&
+					decider(n2, col)                 &&
+					! n2->fixed                      &&
+					! aff_chunk_interferes(chunk, m) &&
+					node_contains(orig_chunk->n, m))
 				{
 					/*
 						following conditions are met:
@@ -812,7 +874,7 @@ static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, w
 		tmp_chunk = new_aff_chunk(env);
 		waitq_put(tmp, tmp_chunk);
 		expand_chunk_from(env, node, visited, tmp_chunk, c, decider, col);
-		assert(bitset_popcnt(tmp_chunk->nodes) > 0 && "No nodes added to chunk");
+		assert(ARR_LEN(tmp_chunk->n) > 0 && "No nodes added to chunk");
 
 		/* remember the local best */
 		aff_chunk_assure_weight(env, tmp_chunk);
@@ -874,13 +936,13 @@ static INLINE int is_loose(co_mst_irn_t *node)
 static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
 	int *neigh_cols = alloca(env->n_regs * sizeof(*neigh_cols));
 	int n_loose = 0;
-	double coeff;
+	real_t coeff;
 	int i;
 
 	for (i = 0; i < env->n_regs; ++i) {
 		neigh_cols[i] = 0;
 		costs[i].col = i;
-		costs[i].cost = bitset_is_set(node->adm_colors, i) ? node->constr_factor : 0.0;
+		costs[i].cost = bitset_is_set(node->adm_colors, i) ? node->constr_factor : REAL(0.0);
 	}
 
 	for (i = 0; i < node->n_neighs; ++i) {
@@ -889,16 +951,14 @@ static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cos
 		if (is_loose(n)) {
 			++n_loose;
 			++neigh_cols[col];
-		}
-
-		else
-			costs[col].cost = 0.0;
+		} else
+			costs[col].cost = REAL(0.0);
 	}
 
 	if (n_loose > 0) {
-		coeff = 1.0 / n_loose;
+		coeff = REAL(1.0) / n_loose;
 		for (i = 0; i < env->n_regs; ++i)
-			costs[i].cost *= 1.0 - coeff * neigh_cols[i];
+			costs[i].cost *= REAL(1.0) - coeff * neigh_cols[i];
 	}
 }
 
@@ -928,7 +988,7 @@ static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int
 		determine_color_costs(env, node, costs);
 
 		/* Since the node must not have the not_col, set the costs for that color to "infinity" */
-		costs[exclude_col].cost = 0.0;
+		costs[exclude_col].cost = REAL(0.0);
 
 		/* sort the colors according costs, cheapest first. */
 		qsort(costs, env->n_regs, sizeof(costs[0]), cmp_col_cost_gt);
@@ -966,7 +1026,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
 		int j;
 
 		/* If the costs for that color (and all successive) are infinite, bail out we won't make it anyway. */
-		if (costs[i].cost == 0.0)
+		if (costs[i].cost == REAL(0.0))
 			return 0;
 
 		/* Set the new color of the node and mark the node as temporarily fixed. */
@@ -1087,27 +1147,27 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	waitq       *best_starts  = NULL;
 	col_cost_t  *order        = alloca(env->n_regs * sizeof(order[0]));
 	bitset_t    *visited;
-	int         idx, len, i;
+	int         idx, len, i, nidx, pos;
 	struct list_head changed;
-	bitset_pos_t pos;
 
-	DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
+	DB((dbg, LEVEL_2, "fragmentizing chunk #%u", c->id));
 	DBG_AFF_CHUNK(env, LEVEL_2, c);
 	DB((dbg, LEVEL_2, "\n"));
 
-	stat_ev_ctx_push_fmt("heur4_color_chunk", "%d", c->id);
+	stat_ev_ctx_push_fmt("heur4_color_chunk", "%u", c->id);
 
 	++env->chunk_visited;
 
 	/* compute color preference */
 	memset(order, 0, env->n_regs * sizeof(order[0]));
 
-	bitset_foreach (c->interfere, pos) {
-		ir_node      *n    = get_idx_irn(env->co->irg, pos);
+	for (pos = 0, len = ARR_LEN(c->interfere); pos < len; ++pos) {
+		const ir_node *n = c->interfere[pos];
 		co_mst_irn_t *node = get_co_mst_irn(env, n);
 		aff_chunk_t *chunk = node->chunk;
 
-		if (is_loose(node) && chunk && chunk->visited < env->chunk_visited && !chunk->deleted) {
+		if (is_loose(node) && chunk && chunk->visited < env->chunk_visited) {
+			assert(!chunk->deleted);
 			chunk->visited = env->chunk_visited;
 			++n_int_chunks;
 
@@ -1118,9 +1178,9 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	}
 
 	for (i = 0; i < env->n_regs; ++i) {
-		double dislike = n_int_chunks > 0 ? 1.0 - order[i].cost / n_int_chunks : 0.0;
+		real_t dislike = n_int_chunks > 0 ? REAL(1.0) - order[i].cost / n_int_chunks : REAL(0.0);
 		order[i].col  = i;
-		order[i].cost = (1.0 - dislike_influence) * c->color_affinity[i].cost + dislike_influence * dislike;
+		order[i].cost = (REAL(1.0) - dislike_influence) * c->color_affinity[i].cost + dislike_influence * dislike;
 	}
 
 	qsort(order, env->n_regs, sizeof(order[0]), cmp_col_cost_gt);
@@ -1198,7 +1258,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 		if (local_best) {
 			aff_chunk_assure_weight(env, local_best);
 
-			DB((dbg, LEVEL_3, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
+			DB((dbg, LEVEL_3, "\t\tlocal best chunk (id %u) for color %d: ", local_best->id, col));
 			DBG_AFF_CHUNK(env, LEVEL_3, local_best);
 
 			if (! best_chunk || best_chunk->weight < local_best->weight) {
@@ -1207,7 +1267,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 				if (best_starts)
 					del_waitq(best_starts);
 				best_starts = good_starts;
-				DB((dbg, LEVEL_3, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
+				DB((dbg, LEVEL_3, "\n\t\t... setting global best chunk (id %u), color %d\n", best_chunk->id, best_color));
 			} else {
 				DB((dbg, LEVEL_3, "\n\t\t... omitting, global best is better\n"));
 				del_waitq(good_starts);
@@ -1239,7 +1299,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 		return;
 	}
 
-	DB((dbg, LEVEL_2, "\tbest chunk #%d ", best_chunk->id));
+	DB((dbg, LEVEL_2, "\tbest chunk #%u ", best_chunk->id));
 	DBG_AFF_CHUNK(env, LEVEL_2, best_chunk);
 	DB((dbg, LEVEL_2, "using color %d\n", best_color));
 
@@ -1249,7 +1309,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 		int res;
 
 		/* bring the node to the color. */
-		DB((dbg, LEVEL_4, "\tManifesting color %d for %+F, chunk #%d\n", best_color, node->irn, best_chunk->id));
+		DB((dbg, LEVEL_4, "\tManifesting color %d for %+F, chunk #%u\n", best_color, node->irn, best_chunk->id));
 		INIT_LIST_HEAD(&changed);
 		stat_ev_tim_push();
 		res = change_node_color(env, node, best_color, &changed);
@@ -1262,18 +1322,24 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	}
 
 	/* remove the nodes in best chunk from original chunk */
-	bitset_andnot(c->nodes, best_chunk->nodes);
-	for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
-		const ir_node *irn = c->n[idx];
+	len = ARR_LEN(best_chunk->n);
+	for (idx = 0; idx < len; ++idx) {
+		const ir_node *irn = best_chunk->n[idx];
+		int pos = nodes_bsearch(c->n, irn);
 
-		if (bitset_is_set(best_chunk->nodes, get_irn_idx(irn))) {
-			int last = ARR_LEN(c->n) - 1;
+		if (pos > 0)
+			c->n[pos] = NULL;
+	}
+	len = ARR_LEN(c->n);
+	for (idx = nidx = 0; idx < len; ++idx) {
+		const ir_node *irn = c->n[idx];
 
-			c->n[idx] = c->n[last];
-			ARR_SHRINKLEN(c->n, last);
-			len--;
+		if (irn != NULL) {
+			c->n[nidx++] = irn;
 		}
 	}
+	ARR_SHRINKLEN(c->n, nidx);
+
 
 	/* we have to get the nodes back into the original chunk because they are scattered over temporary chunks */
 	for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
@@ -1284,7 +1350,9 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 
 	/* fragment the remaining chunk */
 	visited = bitset_irg_malloc(env->co->irg);
-	bitset_or(visited, best_chunk->nodes);
+	for (idx = 0, len = ARR_LEN(best_chunk->n); idx < len; ++idx)
+		bitset_set(visited, get_irn_idx(best_chunk->n[idx]));
+
 	for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
 		const ir_node *irn = c->n[idx];
 		if (! bitset_is_set(visited, get_irn_idx(irn))) {
@@ -1322,6 +1390,8 @@ int co_solve_heuristic_mst(copy_opt_t *co) {
 	ir_node      *irn;
 	co_mst_env_t mst_env;
 
+	last_chunk_id = 0;
+
 	stat_ev_tim_push();
 
 	/* init phase */
@@ -1347,11 +1417,11 @@ int co_solve_heuristic_mst(copy_opt_t *co) {
 		mst_env.single_cols[i] = vec;
 		for (j = 0; j < n_regs; ++j) {
 			vec[j].col  = j;
-			vec[j].cost = 0.0;
+			vec[j].cost = REAL(0.0);
 		}
 		vec[i].col  = 0;
 		vec[0].col  = i;
-		vec[0].cost = 1.0;
+		vec[0].cost = REAL(1.0);
 	}
 
 	DBG((dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
@@ -1366,18 +1436,19 @@ int co_solve_heuristic_mst(copy_opt_t *co) {
 		aff_chunk_t *chunk = pqueue_get(mst_env.chunks);
 
 		color_aff_chunk(&mst_env, chunk);
-		DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%d) done\n", chunk->id));
+		DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%u) done\n", chunk->id));
 		delete_aff_chunk(&mst_env, chunk);
 	}
 
 	/* apply coloring */
 	foreach_phase_irn(&mst_env.ph, irn) {
-		co_mst_irn_t *mirn = get_co_mst_irn(&mst_env, irn);
+		co_mst_irn_t *mirn;
 		const arch_register_t *reg;
 
 		if (arch_irn_is(mst_env.aenv, irn, ignore))
 			continue;
 
+		mirn = get_co_mst_irn(&mst_env, irn);
 		// assert(mirn->fixed && "Node should have fixed color");
 
 		/* skip nodes where color hasn't changed */