/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
- *
* This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
*/
/**
* @brief Simple copy minimization heuristics.
* @author Christian Wuerdig
* @date 27.04.2007
- * @version $Id$
*
* This is the C implementation of the mst algorithm
* originally written in Java by Sebastian Hack.
* (also known as "heur3" :)
* Performs simple copy minimization.
*/
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif /* HAVE_CONFIG_H */
+
+#define DISABLE_STATEV
#include <float.h>
#include "irnode_t.h"
#include "bitset.h"
#include "raw_bitset.h"
-#include "irphase_t.h"
+#include "irnodemap.h"
#include "pqueue.h"
#include "xmalloc.h"
#include "pdeq.h"
-#include "pset.h"
#include "irprintf.h"
-#include "irbitset.h"
+#include "util.h"
+#include "irtools.h"
#include "error.h"
#include "list.h"
+#include "statev_t.h"
#include "bearch.h"
#include "beifg.h"
#include "bemodule.h"
-#define COL_COST_INFEASIBLE DBL_MAX
-#define AFF_NEIGHBOUR_FIX_BENEFIT 128.0
-#define NEIGHBOUR_CONSTR_COSTS 64.0
+#ifdef DEBUG_libfirm
-#ifdef NDEBUG
+#define DBG_AFF_CHUNK(env, level, chunk) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_aff_chunk((env), (chunk)); } while (0)
+#define DBG_COL_COST(env, level, cost) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_col_cost((env), (cost)); } while (0)
-#define DBG_AFF_CHUNK(env, level, chunk)
-#define DBG_COL_COST(env, level, cost)
+static firm_dbg_module_t *dbg = NULL;
#else
-static firm_dbg_module_t *dbg = NULL;
-#define DBG_AFF_CHUNK(env, level, chunk) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_aff_chunk((env), (chunk)); } while(0)
-#define DBG_COL_COST(env, level, cost) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_col_cost((env), (cost)); } while(0)
+#define DBG_AFF_CHUNK(env, level, chunk)
+#define DBG_COL_COST(env, level, cost)
#endif
-static int last_chunk_id = 0;
+typedef float real_t;
+#define REAL(C) (C ## f)
-typedef struct _col_cost_t {
- int col;
- double cost;
+static unsigned last_chunk_id = 0;
+static int recolor_limit = 7;
+static double dislike_influence = REAL(0.1);
+
+typedef struct col_cost_t {
+ int col;
+ real_t cost;
} col_cost_t;
/**
* An affinity chunk.
*/
-typedef struct _aff_chunk_t {
- 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. */
- 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. */
+typedef struct aff_chunk_t {
+ const ir_node **n; /**< An ARR_F containing all nodes of the 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; /**< For debugging: Set if the was deleted. */
+ unsigned id; /**< An id of this chunk. */
+ unsigned visited;
+ list_head list;
+ col_cost_t color_affinity[1];
} aff_chunk_t;
/**
* An affinity edge.
*/
-typedef struct _aff_edge_t {
- ir_node *src; /**< Source node. */
- ir_node *tgt; /**< Target node. */
- double weight; /**< The weight of this edge. */
+typedef struct aff_edge_t {
+ const ir_node *src; /**< Source node. */
+ const ir_node *tgt; /**< Target node. */
+ int weight; /**< The weight of this edge. */
} aff_edge_t;
/* main coalescing environment */
-typedef struct _co_mst_env_t {
+typedef struct co_mst_env_t {
int n_regs; /**< number of regs in class */
- int k; /**< number of non-ignore registers in class */
- bitset_t *ignore_regs; /**< set containing all global ignore registers */
- ir_phase ph; /**< phase object holding data for nodes */
- pqueue *chunks; /**< priority queue for chunks */
- pset *chunkset; /**< set holding all chunks */
+ bitset_t const *allocatable_regs; /**< set containing all global ignore registers */
+ ir_nodemap map; /**< phase object holding data for nodes */
+ struct obstack obst;
+ pqueue_t *chunks; /**< priority queue for chunks */
+ list_head chunklist; /**< list holding all chunks */
be_ifg_t *ifg; /**< the interference graph */
- const arch_env_t *aenv; /**< the arch environment */
copy_opt_t *co; /**< the copy opt object */
+ unsigned chunk_visited;
+ col_cost_t **single_cols;
} co_mst_env_t;
/* stores coalescing related information for a node */
-typedef struct _co_mst_irn_t {
- ir_node *irn; /**< the irn this information belongs to */
+typedef struct co_mst_irn_t {
+ const ir_node *irn; /**< the irn this information belongs to */
aff_chunk_t *chunk; /**< the chunk this irn belongs to */
bitset_t *adm_colors; /**< set of admissible colors for this irn */
ir_node **int_neighs; /**< array of all interfering neighbours (cached for speed reasons) */
int tmp_col; /**< a temporary assigned color */
unsigned fixed : 1; /**< the color is fixed */
struct list_head list; /**< Queue for coloring undo. */
+ 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)))
+/**
+ * In case there is no phase information for irn, initialize it.
+ */
+static co_mst_irn_t *co_mst_irn_init(co_mst_env_t *env, const ir_node *irn)
+{
+ co_mst_irn_t *res = OALLOC(&env->obst, co_mst_irn_t);
+
+ const arch_register_req_t *req;
+ neighbours_iter_t nodes_it;
+ unsigned len;
+
+ res->irn = irn;
+ res->chunk = NULL;
+ res->fixed = 0;
+ res->tmp_col = -1;
+ res->int_neighs = NULL;
+ res->int_aff_neigh = 0;
+ res->col = arch_get_irn_register(irn)->index;
+ res->init_col = res->col;
+ INIT_LIST_HEAD(&res->list);
+
+ DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn));
+
+ /* set admissible registers */
+ res->adm_colors = bitset_obstack_alloc(&env->obst, env->n_regs);
+
+ /* Exclude colors not assignable to the irn */
+ req = arch_get_irn_register_req(irn);
+ if (arch_register_req_is(req, limited)) {
+ rbitset_copy_to_bitset(req->limited, res->adm_colors);
+ /* exclude global ignore registers as well */
+ bitset_and(res->adm_colors, env->allocatable_regs);
+ } else {
+ bitset_copy(res->adm_colors, env->allocatable_regs);
+ }
+
+ /* compute the constraint factor */
+ res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcount(res->adm_colors)) / env->n_regs;
+
+ /* set the number of interfering affinity neighbours to -1, they are calculated later */
+ res->int_aff_neigh = -1;
+
+ /* build list of interfering neighbours */
+ len = 0;
+ be_ifg_foreach_neighbour(env->ifg, &nodes_it, irn, neigh) {
+ if (!arch_irn_is_ignore(neigh)) {
+ obstack_ptr_grow(&env->obst, neigh);
+ ++len;
+ }
+ }
+ res->int_neighs = (ir_node**)obstack_finish(&env->obst);
+ res->n_neighs = len;
+ return res;
+}
+
+static co_mst_irn_t *get_co_mst_irn(co_mst_env_t *env, const ir_node *node)
+{
+ co_mst_irn_t *res = ir_nodemap_get(co_mst_irn_t, &env->map, node);
+ if (res == NULL) {
+ res = co_mst_irn_init(env, node);
+ ir_nodemap_insert(&env->map, node, res);
+ }
+ return res;
+}
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;
+static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c)
+{
+ 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, "}");
/**
* Dump all admissible colors to stderr.
*/
-static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node) {
- bitset_pos_t idx;
+static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node)
+{
(void) env;
- if (bitset_popcnt(node->adm_colors) < 1)
+ if (bitset_popcount(node->adm_colors) < 1)
fprintf(stderr, "no admissible colors?!?");
else {
- bitset_foreach(node->adm_colors, idx)
- fprintf(stderr, " %d", idx);
+ bitset_foreach(node->adm_colors, idx) {
+ ir_fprintf(stderr, " %zu", idx);
+ }
}
}
/**
* Dump color-cost pairs to stderr.
*/
-static void dbg_col_cost(const co_mst_env_t *env, const col_cost_t *cost) {
+static void dbg_col_cost(const co_mst_env_t *env, const col_cost_t *cost)
+{
int i;
- for (i = 0; i < env->n_regs; ++i) {
- if (cost[i].cost == COL_COST_INFEASIBLE)
- fprintf(stderr, " (%d, INF)", cost[i].col);
- else
- fprintf(stderr, " (%d, %.1f)", cost[i].col, cost[i].cost);
- }
+ for (i = 0; i < env->n_regs; ++i)
+ fprintf(stderr, " (%d, %.4f)", cost[i].col, cost[i].cost);
}
#endif /* DEBUG_libfirm */
-static INLINE int get_mst_irn_col(const co_mst_irn_t *node) {
+static inline int get_mst_irn_col(const co_mst_irn_t *node)
+{
return node->tmp_col >= 0 ? node->tmp_col : node->col;
}
/**
* @return 1 if node @p node has color @p col, 0 otherwise.
*/
-static int decider_has_color(const co_mst_irn_t *node, int col) {
+static int decider_has_color(const co_mst_irn_t *node, int col)
+{
return get_mst_irn_col(node) == col;
}
/**
* @return 1 if node @p node has not color @p col, 0 otherwise.
*/
-static int decider_hasnot_color(const co_mst_irn_t *node, int col) {
+static int decider_hasnot_color(const co_mst_irn_t *node, int col)
+{
return get_mst_irn_col(node) != col;
}
/**
* Always returns true.
*/
-static int decider_always_yes(const co_mst_irn_t *node, int col) {
+static int decider_always_yes(const co_mst_irn_t *node, int col)
+{
(void) node;
(void) col;
return 1;
}
-static int cmp_node_order(const void *a, const void *b)
-{
- return 0;
-}
-
/** compares two affinity edges by its weight */
-static int cmp_aff_edge(const void *a, const void *b) {
- const aff_edge_t *e1 = a;
- const aff_edge_t *e2 = b;
+static int cmp_aff_edge(const void *a, const void *b)
+{
+ const aff_edge_t *e1 = (const aff_edge_t*)a;
+ const aff_edge_t *e2 = (const aff_edge_t*)b;
if (e2->weight == e1->weight) {
if (e2->src->node_idx == e1->src->node_idx)
}
/** compares to color-cost pairs */
-static int cmp_col_cost(const void *a, const void *b) {
- const col_cost_t *c1 = a;
- const col_cost_t *c2 = b;
+static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b)
+{
+ const col_cost_t *c1 = (const col_cost_t*)a;
+ const col_cost_t *c2 = (const col_cost_t*)b;
+ real_t diff = c1->cost - c2->cost;
+
+ if (diff < 0)
+ return 1;
+ if (diff > 0)
+ return -1;
- return c1->cost < c2->cost ? -1 : 1;
+ return QSORT_CMP(c1->col, c2->col);
+}
+
+static int cmp_col_cost_gt(const void *a, const void *b)
+{
+ const col_cost_t *c1 = (const col_cost_t*)a;
+ const col_cost_t *c2 = (const col_cost_t*)b;
+ real_t diff = c2->cost - c1->cost;
+
+ if (diff > 0)
+ return 1;
+ if (diff < 0)
+ return -1;
+
+ return QSORT_CMP(c1->col, c2->col);
}
/**
* 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));
+static inline aff_chunk_t *new_aff_chunk(co_mst_env_t *env)
+{
+ aff_chunk_t *c = XMALLOCF(aff_chunk_t, color_affinity, env->n_regs);
+ 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(ir_node *, 0);
- c->nodes = bitset_irg_malloc(env->co->irg);
- c->interfere = bitset_irg_malloc(env->co->irg);
- c->id = last_chunk_id++;
- pset_insert(env->chunkset, c, c->id);
+ c->deleted = 0;
+ c->id = ++last_chunk_id;
+ c->visited = 0;
+ list_add(&c->list, &env->chunklist);
return c;
}
/**
* Frees all memory allocated by an affinity chunk.
*/
-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);
+static inline void delete_aff_chunk(aff_chunk_t *c)
+{
+ list_del(&c->list);
+ DEL_ARR_F(c->interfere);
DEL_ARR_F(c->n);
c->deleted = 1;
free(c);
}
/**
- * Adds a node to an affinity chunk
+ * 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 void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
- int i;
+static inline int nodes_bsearch(const ir_node **arr, const ir_node *n)
+{
+ int hi = ARR_LEN(arr);
+ int lo = 0;
- if (bitset_is_set(c->nodes, get_irn_idx(node->irn)))
- return;
+ while (lo < hi) {
+ int md = lo + ((hi - lo) >> 1);
- c->weight_consistent = 0;
- node->chunk = c;
- bitset_set(c->nodes, get_irn_idx(node->irn));
+ if (arr[md] == n)
+ return md;
+ if (arr[md] < n)
+ lo = md + 1;
+ else
+ hi = md;
+ }
+
+ return ~lo;
+}
- ARR_APP1(ir_node *, c->n, node->irn);
+/** 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;
+}
- for (i = node->n_neighs - 1; i >= 0; --i) {
- ir_node *neigh = node->int_neighs[i];
- bitset_set(c->interfere, get_irn_idx(neigh));
+/**
+ * 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;
}
/**
- * In case there is no phase information for irn, initialize it.
+ * Adds a node to an affinity chunk
*/
-static void *co_mst_irn_init(ir_phase *ph, ir_node *irn, void *old) {
- co_mst_irn_t *res = old ? old : phase_alloc(ph, sizeof(res[0]));
- co_mst_env_t *env = ph->priv;
-
- if (res != old) {
- const arch_register_req_t *req;
- void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
- ir_node *neigh;
- unsigned len;
-
- res->irn = irn;
- res->chunk = NULL;
- res->fixed = 0;
- res->tmp_col = -1;
- res->int_neighs = NULL;
- res->int_aff_neigh = 0;
- res->col = arch_register_get_index(arch_get_irn_register(env->aenv, irn));
- res->init_col = res->col;
- INIT_LIST_HEAD(&res->list);
-
- DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn));
-
- /* set admissible registers */
- res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs);
-
- /* Exclude colors not assignable to the irn */
- req = arch_get_register_req(env->aenv, irn, -1);
- if (arch_register_req_is(req, limited))
- rbitset_copy_to_bitset(req->limited, res->adm_colors);
- else
- bitset_set_all(res->adm_colors);
+static inline void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node)
+{
+ int i;
- /* exclude global ignore registers as well */
- bitset_andnot(res->adm_colors, env->ignore_regs);
+ if (! nodes_insert(&c->n, node->irn))
+ return;
- /* set the number of interfering affinity neighbours to -1, they are calculated later */
- res->int_aff_neigh = -1;
+ c->weight_consistent = 0;
+ node->chunk = c;
- /* build list of interfering neighbours */
- len = 0;
- be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
- if (! arch_irn_is(env->aenv, neigh, ignore)) {
- obstack_ptr_grow(phase_obst(ph), neigh);
- ++len;
- }
- }
- res->int_neighs = obstack_finish(phase_obst(ph));
- res->n_neighs = len;
+ for (i = node->n_neighs - 1; i >= 0; --i) {
+ ir_node *neigh = node->int_neighs[i];
+ nodes_insert(&c->interfere, neigh);
}
- return res;
}
/**
* 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, 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) {
- bitset_t *tmp;
+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 */
- tmp = bitset_alloca(get_irg_last_idx(env->co->irg));
- tmp = bitset_copy(tmp, c1->interfere);
- tmp = bitset_and(tmp, c2->nodes);
+ for (i = ARR_LEN(c2->n) - 1; i >= 0; --i) {
+ const ir_node *irn = c2->n[i];
- return bitset_popcnt(tmp) > 0;
+ if (node_contains(c1->interfere, irn))
+ return 1;
+ }
+ return 0;
}
/**
* Returns the affinity chunk of @p irn or creates a new
* one with @p irn as element if there is none assigned.
*/
-static INLINE aff_chunk_t *get_aff_chunk(co_mst_env_t *env, ir_node *irn) {
+static inline aff_chunk_t *get_aff_chunk(co_mst_env_t *env, const ir_node *irn)
+{
co_mst_irn_t *node = get_co_mst_irn(env, irn);
return node->chunk;
}
* are no interference edges from chunk(src) to chunk(tgt)).
* @return 1 if successful, 0 if not possible
*/
-static int aff_chunk_absorb(co_mst_env_t *env, ir_node *src, ir_node *tgt) {
+static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node *tgt)
+{
aff_chunk_t *c1 = get_aff_chunk(env, src);
aff_chunk_t *c2 = get_aff_chunk(env, tgt);
-#ifndef NDEBUG
- DB((dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1 ? c1->id : -1));
+#ifdef DEBUG_libfirm
+ DB((dbg, LEVEL_4, "Attempt to let c1 (id %u): ", c1 ? c1->id : 0));
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 : 0));
if (c2) {
DBG_AFF_CHUNK(env, LEVEL_4, c2);
} else {
}
} 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) {
- ir_node *n = c2->n[idx];
- co_mst_irn_t *mn = get_co_mst_irn(env, n);
+ for (idx = 0, len = ARR_LEN(c2->n); idx < len; ++idx)
+ aff_chunk_add_node(c1, get_co_mst_irn(env, c2->n[idx]));
- mn->chunk = c1;
-
- if (! bitset_is_set(c1->nodes, get_irn_idx(n)))
- ARR_APP1(ir_node *, c1->n, n);
+ for (idx = 0, len = ARR_LEN(c2->interfere); idx < len; ++idx) {
+ const ir_node *irn = c2->interfere[idx];
+ nodes_insert(&c1->interfere, irn);
}
- bitset_or(c1->nodes, c2->nodes);
- bitset_or(c1->interfere, c2->interfere);
c1->weight_consistent = 0;
- delete_aff_chunk(env, c2);
+ delete_aff_chunk(c2);
goto absorbed;
}
DB((dbg, LEVEL_4, " ... c1 interferes with c2, skipped\n"));
/**
* Assures that the weight of the given chunk is consistent.
*/
-static void aff_chunk_assure_weight(const co_mst_env_t *env, aff_chunk_t *c) {
+static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c)
+{
if (! c->weight_consistent) {
int w = 0;
- int idx, len;
+ int idx, len, i;
+
+ for (i = 0; i < env->n_regs; ++i) {
+ c->color_affinity[i].col = i;
+ c->color_affinity[i].cost = REAL(0.0);
+ }
for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
- ir_node *n = c->n[idx];
- const affinity_node_t *an = get_affinity_info(env->co, n);
+ const ir_node *n = c->n[idx];
+ const affinity_node_t *an = get_affinity_info(env->co, n);
+ co_mst_irn_t *node = get_co_mst_irn(env, n);
+
+ node->chunk = c;
+ if (node->constr_factor > REAL(0.0)) {
+ bitset_foreach (node->adm_colors, col)
+ c->color_affinity[col].cost += node->constr_factor;
+ }
if (an != NULL) {
- neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
- const ir_node *m = neigh->irn;
- const int m_idx = get_irn_idx(m);
+ const ir_node *m = neigh->irn;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is_ignore(m))
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 *= (REAL(1.0) / ARR_LEN(c->n));
+
c->weight = w;
+ // c->weight = bitset_popcount(c->nodes);
c->weight_consistent = 1;
}
}
/**
* Count the number of interfering affinity neighbours
*/
-static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an) {
- const neighb_t *neigh;
- ir_node *irn = an->irn;
+static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an)
+{
+ const ir_node *irn = an->irn;
const co_mst_irn_t *node = get_co_mst_irn(env, irn);
int res = 0;
const ir_node *n = neigh->irn;
int i;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, n, ignore))
+ if (arch_irn_is_ignore(n))
continue;
/* check if the affinity neighbour interfere */
* merged if there are no interference edges from one
* chunk to the other.
*/
-static void build_affinity_chunks(co_mst_env_t *env) {
- void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
- aff_edge_t *edges = NEW_ARR_F(aff_edge_t, 0);
- ir_node *n;
- int i, len;
- aff_chunk_t *curr_chunk;
+static void build_affinity_chunks(co_mst_env_t *env)
+{
+ aff_edge_t *edges = NEW_ARR_F(aff_edge_t, 0);
/* at first we create the affinity edge objects */
- be_ifg_foreach_node(env->ifg, nodes_it, n) {
+ be_ifg_foreach_node(env->ifg, n) {
int n_idx = get_irn_idx(n);
co_mst_irn_t *n1;
affinity_node_t *an;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, n, ignore))
+ if (arch_irn_is_ignore(n))
continue;
n1 = get_co_mst_irn(env, n);
an = get_affinity_info(env->co, n);
if (an != NULL) {
- neighb_t *neigh;
-
if (n1->int_aff_neigh < 0)
n1->int_aff_neigh = count_interfering_aff_neighs(env, an);
/* build the affinity edges */
co_gs_foreach_neighb(an, neigh) {
- ir_node *m = neigh->irn;
- int m_idx = get_irn_idx(m);
+ const ir_node *m = neigh->irn;
+ int m_idx = get_irn_idx(m);
/* record the edge in only one direction */
if (n_idx < m_idx) {
aff_edge_t edge;
/* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
edge.src = n;
* these weights are pure hackery ;-).
* It's not chriswue's fault but mine.
*/
- edge.weight = (double)neigh->costs / (double)(1 + n1->int_aff_neigh + n2->int_aff_neigh);
+ edge.weight = neigh->costs;
ARR_APP1(aff_edge_t, edges, edge);
}
}
}
/* now: sort edges and build the affinity chunks */
- len = ARR_LEN(edges);
+ size_t const len = ARR_LEN(edges);
qsort(edges, len, sizeof(edges[0]), cmp_aff_edge);
- for (i = 0; i < len; ++i) {
+ for (size_t i = 0; i < len; ++i) {
DBG((dbg, LEVEL_1, "edge (%u,%u) %f\n", edges[i].src->node_idx, edges[i].tgt->node_idx, edges[i].weight));
(void)aff_chunk_absorb(env, edges[i].src, edges[i].tgt);
}
/* now insert all chunks into a priority queue */
- foreach_pset(env->chunkset, curr_chunk) {
+ list_for_each_entry(aff_chunk_t, curr_chunk, &env->chunklist, list) {
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);
- if (mirn->chunk == NULL) {
- /* no chunk is allocated so far, do it now */
- aff_chunk_t *curr_chunk = new_aff_chunk(env);
- aff_chunk_add_node(curr_chunk, mirn);
+ for (size_t pn = 0; pn < ARR_LEN(env->map.data); ++pn) {
+ co_mst_irn_t *mirn = (co_mst_irn_t*)env->map.data[pn];
+ if (mirn == NULL)
+ continue;
+ if (mirn->chunk != NULL)
+ continue;
- aff_chunk_assure_weight(env, curr_chunk);
+ /* no chunk is allocated so far, do it now */
+ aff_chunk_t *curr_chunk = new_aff_chunk(env);
+ aff_chunk_add_node(curr_chunk, mirn);
- DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
- DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
- DBG((dbg, LEVEL_1, "\n"));
+ aff_chunk_assure_weight(env, curr_chunk);
- pqueue_put(env->chunks, curr_chunk, curr_chunk->weight);
- }
+ 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);
}
DEL_ARR_F(edges);
}
+static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chunk_t *chunk)
+{
+ pqueue_t *grow = new_pqueue();
+ ir_node const *max_node = NULL;
+ int max_weight = 0;
+ size_t i;
+
+ for (i = ARR_LEN(chunk->n); i != 0;) {
+ const ir_node *irn = chunk->n[--i];
+ affinity_node_t *an = get_affinity_info(env->co, irn);
+ int w = 0;
+
+ if (arch_irn_is_ignore(irn))
+ continue;
+
+ if (an) {
+ co_gs_foreach_neighb(an, neigh)
+ w += neigh->costs;
+
+ if (w > max_weight) {
+ max_weight = w;
+ max_node = irn;
+ }
+ }
+ }
+
+ if (max_node) {
+ bitset_t *visited = bitset_malloc(get_irg_last_idx(env->co->irg));
+
+ for (i = ARR_LEN(chunk->n); i != 0;)
+ bitset_set(visited, get_irn_idx(chunk->n[--i]));
+
+ pqueue_put(grow, (void *) max_node, max_weight);
+ bitset_clear(visited, get_irn_idx(max_node));
+ i = 0;
+ while (!pqueue_empty(grow)) {
+ ir_node *irn = (ir_node*)pqueue_pop_front(grow);
+ affinity_node_t *an = get_affinity_info(env->co, irn);
+
+ if (arch_irn_is_ignore(irn))
+ continue;
+
+ assert(i <= ARR_LEN(chunk->n));
+ chunk->n[i++] = irn;
+
+ assert(an);
+
+ /* build the affinity edges */
+ co_gs_foreach_neighb(an, neigh) {
+ co_mst_irn_t *node = get_co_mst_irn(env, neigh->irn);
+
+ if (bitset_is_set(visited, get_irn_idx(node->irn))) {
+ pqueue_put(grow, (void *) neigh->irn, neigh->costs);
+ bitset_clear(visited, get_irn_idx(node->irn));
+ }
+ }
+ }
+
+ del_pqueue(grow);
+ bitset_free(visited);
+ }
+}
+
/**
* Greedy collect affinity neighbours into thew new chunk @p chunk starting at node @p node.
*/
{
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);
/* as long as there are nodes in the queue */
while (! waitq_empty(nodes)) {
- co_mst_irn_t *n = waitq_get(nodes);
+ co_mst_irn_t *n = (co_mst_irn_t*)waitq_get(nodes);
affinity_node_t *an = get_affinity_info(env->co, n->irn);
/* check all affinity neighbors */
if (an != NULL) {
- neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
- ir_node *m = neigh->irn;
- int m_idx = get_irn_idx(m);
+ const ir_node *m = neigh->irn;
+ int m_idx = get_irn_idx(m);
co_mst_irn_t *n2;
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
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:
/**
* Fragment the given chunk into chunks having given color and not having given color.
*/
-static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, waitq *tmp) {
- bitset_t *visited = bitset_irg_malloc(env->co->irg);
+static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, waitq *tmp)
+{
+ bitset_t *visited = bitset_malloc(get_irg_last_idx(env->co->irg));
int idx, len;
aff_chunk_t *best = NULL;
for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
- ir_node *irn;
+ const ir_node *irn;
co_mst_irn_t *node;
aff_chunk_t *tmp_chunk;
decide_func_t *decider;
if (get_mst_irn_col(node) == col) {
decider = decider_has_color;
check_for_best = 1;
- DBG((dbg, LEVEL_4, "\tcolor %d wanted", col));
+ DBG((dbg, LEVEL_4, "\tcolor %d wanted\n", col));
}
else {
decider = decider_hasnot_color;
check_for_best = 0;
- DBG((dbg, LEVEL_4, "\tcolor %d forbidden", col));
+ DBG((dbg, LEVEL_4, "\tcolor %d forbidden\n", col));
}
/* create a new chunk starting at current node */
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);
return best;
}
-/**
- * Initializes an array of color-cost pairs.
- * Sets forbidden colors to costs COL_COST_INFEASIBLE and all others to @p c.
- */
-static INLINE void col_cost_init(co_mst_env_t *env, col_cost_t *cost, double c) {
- int i;
-
- for (i = 0; i < env->n_regs; ++i) {
- cost[i].col = i;
- if (bitset_is_set(env->ignore_regs, i))
- cost[i].cost = COL_COST_INFEASIBLE;
- else
- cost[i].cost = c;
- }
-}
-
-/**
- * Initializes an array of color-cost pairs.
- * Sets all colors except color @p col to COL_COST_INFEASIBLE and @p col to 0.0
- */
-static INLINE void col_cost_init_single(co_mst_env_t *env, col_cost_t *cost, int col) {
- assert(! bitset_is_set(env->ignore_regs, col) && "Attempt to use forbidden color.");
- col_cost_init(env, cost, COL_COST_INFEASIBLE);
- cost[col].col = 0;
- cost[0].col = col;
- cost[0].cost = 0.0;
-}
-
/**
* Resets the temporary fixed color of all nodes within wait queue @p nodes.
* ATTENTION: the queue is empty after calling this function!
*/
-static INLINE void reject_coloring(struct list_head *nodes) {
- co_mst_irn_t *n, *temp;
+static inline void reject_coloring(struct list_head *nodes)
+{
DB((dbg, LEVEL_4, "\treject coloring for"));
list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
DB((dbg, LEVEL_4, " %+F", n->irn));
DB((dbg, LEVEL_4, "\n"));
}
-static INLINE void materialize_coloring(struct list_head *nodes) {
- co_mst_irn_t *n, *temp;
+static inline void materialize_coloring(struct list_head *nodes)
+{
list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
assert(n->tmp_col >= 0);
n->col = n->tmp_col;
}
}
-static INLINE void set_temp_color(co_mst_irn_t *node, int col, struct list_head *changed)
+static inline void set_temp_color(co_mst_irn_t *node, int col, struct list_head *changed)
{
assert(col >= 0);
assert(!node->fixed);
assert(node->tmp_col < 0);
assert(node->list.next == &node->list && node->list.prev == &node->list);
+ assert(bitset_is_set(node->adm_colors, col));
list_add_tail(&node->list, changed);
node->tmp_col = col;
}
-static INLINE int is_loose(co_mst_irn_t *node)
+static inline int is_loose(co_mst_irn_t *node)
{
return !node->fixed && node->tmp_col < 0;
}
/**
* Determines the costs for each color if it would be assigned to node @p node.
*/
-static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
- affinity_node_t *an = get_affinity_info(env->co, node->irn);
- neighb_t *aff_neigh;
- bitset_pos_t idx;
- int i;
-
- col_cost_init(env, costs, 0.0);
-
- /* calculate (negative) costs for affinity neighbours */
- if (an != NULL) {
- co_gs_foreach_neighb(an, aff_neigh) {
- ir_node *m = aff_neigh->irn;
- co_mst_irn_t *neigh;
- double c;
-
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
- continue;
-
- neigh = get_co_mst_irn(env, m);
- c = (double)aff_neigh->costs;
+static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs)
+{
+ int *neigh_cols = ALLOCAN(int, env->n_regs);
+ int n_loose = 0;
+ real_t coeff;
+ int i;
- /* calculate costs for fixed affinity neighbours */
- if (!is_loose(neigh)) {
- int col = get_mst_irn_col(neigh);
- costs[col].cost -= c * AFF_NEIGHBOUR_FIX_BENEFIT;
- }
- }
+ 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 : REAL(0.0);
}
- /* calculate (positive) costs for interfering neighbours */
for (i = 0; i < node->n_neighs; ++i) {
- co_mst_irn_t *neigh;
- int col, col_cnt;
- ir_node *int_neigh;
-
- int_neigh = node->int_neighs[i];
-
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, int_neigh, ignore))
- continue;
-
- neigh = get_co_mst_irn(env, int_neigh);
- col = get_mst_irn_col(neigh);
- col_cnt = bitset_popcnt(neigh->adm_colors);
-
- if (!is_loose(neigh)) {
- /* colors of fixed interfering neighbours are infeasible */
- costs[col].cost = COL_COST_INFEASIBLE;
- }
- else if (col_cnt < env->k) {
- /* calculate costs for constrained interfering neighbours */
- double ratio = 1.0 - ((double)col_cnt / (double)env->k);
-
- bitset_foreach_clear(neigh->adm_colors, idx) {
- /* check only explicitly forbidden colors (skip global forbidden ones) */
- if (! bitset_is_set(env->ignore_regs, idx)) {
- costs[col].cost += ratio * NEIGHBOUR_CONSTR_COSTS;
- }
- }
- }
-
- DB((dbg, LEVEL_4, "\tneigh %+F, loose: %d, color: %d\n", int_neigh, is_loose(neigh), col));
+ co_mst_irn_t *n = get_co_mst_irn(env, node->int_neighs[i]);
+ int col = get_mst_irn_col(n);
+ if (is_loose(n)) {
+ ++n_loose;
+ ++neigh_cols[col];
+ } else
+ costs[col].cost = REAL(0.0);
}
- /* set all not admissible colors to COL_COST_INFEASIBLE */
- bitset_foreach_clear(node->adm_colors, idx)
- costs[idx].cost = COL_COST_INFEASIBLE;
+ if (n_loose > 0) {
+ coeff = REAL(1.0) / n_loose;
+ for (i = 0; i < env->n_regs; ++i)
+ costs[i].cost *= REAL(1.0) - coeff * neigh_cols[i];
+ }
}
/* need forward declaration due to recursive call */
-static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed_ones);
+static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed_ones, int depth, int *max_depth, int *trip);
/**
* Tries to change node to a color but @p explude_col.
* @return 1 if succeeded, 0 otherwise.
*/
-static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int exclude_col, struct list_head *changed_ones) {
+static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int exclude_col, struct list_head *changed, int depth, int *max_depth, int *trip)
+{
int col = get_mst_irn_col(node);
int res = 0;
/* neighbours has already a different color -> good, temporary fix it */
if (col != exclude_col) {
if (is_loose(node))
- set_temp_color(node, col, changed_ones);
+ set_temp_color(node, col, changed);
return 1;
}
/* The node has the color it should not have _and_ has not been visited yet. */
if (is_loose(node)) {
- col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
+ col_cost_t *costs = ALLOCAN(col_cost_t, env->n_regs);
/* Get the costs for giving the node a specific color. */
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 = COL_COST_INFEASIBLE;
+ 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);
+ qsort(costs, env->n_regs, sizeof(costs[0]), cmp_col_cost_gt);
/* Try recoloring the node using the color list. */
- res = recolor_nodes(env, node, costs, changed_ones);
+ res = recolor_nodes(env, node, costs, changed, depth + 1, max_depth, trip);
}
return res;
* ATTENTION: Expect @p costs already sorted by increasing costs.
* @return 1 if coloring could be applied, 0 otherwise.
*/
-static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed_ones) {
+static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed, int depth, int *max_depth, int *trip)
+{
int i;
struct list_head local_changed;
- DBG((dbg, LEVEL_1, "\tRecoloring %+F with color-costs", node->irn));
- DBG_COL_COST(env, LEVEL_1, costs);
- DB((dbg, LEVEL_1, "\n"));
+ ++*trip;
+ if (depth > *max_depth)
+ *max_depth = depth;
+
+ DBG((dbg, LEVEL_4, "\tRecoloring %+F with color-costs", node->irn));
+ DBG_COL_COST(env, LEVEL_4, costs);
+ DB((dbg, LEVEL_4, "\n"));
+
+ if (depth >= recolor_limit) {
+ DBG((dbg, LEVEL_4, "\tHit recolor limit\n"));
+ return 0;
+ }
for (i = 0; i < env->n_regs; ++i) {
int tgt_col = costs[i].col;
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 == COL_COST_INFEASIBLE) {
+ if (costs[i].cost == REAL(0.0)) {
+ DBG((dbg, LEVEL_4, "\tAll further colors forbidden\n"));
return 0;
}
neigh = node->int_neighs[j];
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, neigh, ignore))
+ if (arch_irn_is_ignore(neigh))
continue;
nn = get_co_mst_irn(env, neigh);
*/
if (get_mst_irn_col(nn) == tgt_col) {
/* try to color neighbour with tgt_col forbidden */
- neigh_ok = change_node_color_excluded(env, nn, tgt_col, &local_changed);
+ neigh_ok = change_node_color_excluded(env, nn, tgt_col, &local_changed, depth + 1, max_depth, trip);
if (!neigh_ok)
break;
of the current node, every thing was ok and we can return safely.
*/
if (neigh_ok) {
- co_mst_irn_t *n, *temp;
/* append the local_changed ones to global ones */
- list_splice(&local_changed, changed_ones);
+ list_splice(&local_changed, changed);
return 1;
}
else {
}
}
+ DBG((dbg, LEVEL_4, "\tAll colors failed\n"));
return 0;
}
/**
- * Tries to bring node @p node and all it's neighbours to color @p tgt_col.
+ * Tries to bring node @p node and all its neighbours to color @p tgt_col.
* @return 1 if color @p col could be applied, 0 otherwise
*/
-static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, struct list_head *changed_ones) {
+static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, struct list_head *changed)
+{
int col = get_mst_irn_col(node);
/* if node already has the target color -> good, temporary fix it */
if (col == tgt_col) {
DBG((dbg, LEVEL_4, "\t\tCNC: %+F has already color %d, fix temporary\n", node->irn, tgt_col));
if (is_loose(node))
- set_temp_color(node, tgt_col, changed_ones);
+ set_temp_color(node, tgt_col, changed);
return 1;
}
/*
Node has not yet a fixed color and target color is admissible
- -> try to recolor node and it's affinity neighbours
+ -> try to recolor node and its affinity neighbours
*/
if (is_loose(node) && bitset_is_set(node->adm_colors, tgt_col)) {
- col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
- int res;
+ col_cost_t *costs = env->single_cols[tgt_col];
+ int res, max_depth, trip;
- col_cost_init_single(env, costs, tgt_col);
+ max_depth = 0;
+ trip = 0;
DBG((dbg, LEVEL_4, "\t\tCNC: Attempt to recolor %+F ===>>\n", node->irn));
- res = recolor_nodes(env, node, costs, changed_ones);
+ res = recolor_nodes(env, node, costs, changed, 0, &max_depth, &trip);
DBG((dbg, LEVEL_4, "\t\tCNC: <<=== Recoloring of %+F %s\n", node->irn, res ? "succeeded" : "failed"));
+ stat_ev_int("heur4_recolor_depth_max", max_depth);
+ stat_ev_int("heur4_recolor_trip", trip);
+
return res;
}
-#ifndef NDEBUG
+#ifdef DEBUG_libfirm
if (firm_dbg_get_mask(dbg) & LEVEL_4) {
if (!is_loose(node))
DB((dbg, LEVEL_4, "\t\tCNC: %+F has already fixed color %d\n", node->irn, col));
* Tries to color an affinity chunk (or at least a part of it).
* Inserts uncolored parts of the chunk as a new chunk into the priority queue.
*/
-static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
+static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c)
+{
aff_chunk_t *best_chunk = NULL;
+ int n_nodes = ARR_LEN(c->n);
int best_color = -1;
- int did_all = 0;
+ int n_int_chunks = 0;
waitq *tmp_chunks = new_waitq();
waitq *best_starts = NULL;
+ col_cost_t *order = ALLOCANZ(col_cost_t, env->n_regs);
bitset_t *visited;
- int col, idx, len;
- co_mst_irn_t *n;
- struct list_head changed_ones;
-
- DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
+ int i;
+ size_t idx;
+ size_t len;
+ size_t nidx;
+ size_t pos;
+ struct list_head changed;
+
+ 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", "%u", c->id);
+
+ ++env->chunk_visited;
+
+ /* compute color preference */
+ 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) {
+ assert(!chunk->deleted);
+ chunk->visited = env->chunk_visited;
+ ++n_int_chunks;
+
+ aff_chunk_assure_weight(env, chunk);
+ for (i = 0; i < env->n_regs; ++i)
+ order[i].cost += chunk->color_affinity[i].cost;
+ }
+ }
+
+ for (i = 0; i < env->n_regs; ++i) {
+ 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 = (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);
+
+ DBG_COL_COST(env, LEVEL_2, order);
+ DB((dbg, LEVEL_2, "\n"));
/* check which color is the "best" for the given chunk.
* if we found a color which was ok for all nodes, we take it
* TODO Sebastian: Perhaps we should at all nodes and figure out
* a suitable color using costs as done above (determine_color_costs).
*/
- for (col = 0; col < env->n_regs && !did_all; ++col) {
- int one_good = 0;
- waitq *good_starts = new_waitq();
+ for (i = 0; i < env->n_regs; ++i) {
+ int col = order[i].col;
+ waitq *good_starts;
aff_chunk_t *local_best;
+ int n_succeeded;
/* skip ignore colors */
- if (bitset_is_set(env->ignore_regs, col))
+ if (!bitset_is_set(env->allocatable_regs, col))
continue;
- DB((dbg, LEVEL_3, "\ttrying color %d\n", col));
-
- /* suppose we can color all nodes to the same color */
- did_all = 1;
+ DB((dbg, LEVEL_2, "\ttrying color %d\n", col));
- INIT_LIST_HEAD(&changed_ones);
+ n_succeeded = 0;
+ good_starts = new_waitq();
/* try to bring all nodes of given chunk to the current color. */
for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
- ir_node *irn = c->n[idx];
- co_mst_irn_t *node = get_co_mst_irn(env, irn);
- int good = 0;
+ const ir_node *irn = c->n[idx];
+ co_mst_irn_t *node = get_co_mst_irn(env, irn);
+ int good;
assert(! node->fixed && "Node must not have a fixed color.");
DB((dbg, LEVEL_4, "\t\tBringing %+F from color %d to color %d ...\n", irn, node->col, col));
The order of the colored nodes is important, so we record the successfully
colored ones in the order they appeared.
*/
- good = change_node_color(env, node, col, &changed_ones);
+ INIT_LIST_HEAD(&changed);
+ stat_ev_tim_push();
+ good = change_node_color(env, node, col, &changed);
+ stat_ev_tim_pop("heur4_recolor");
if (good) {
waitq_put(good_starts, node);
+ materialize_coloring(&changed);
+ node->fixed = 1;
}
- one_good |= good;
- did_all &= good;
+ else
+ reject_coloring(&changed);
- DB((dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, col, one_good ? "succeeded" : "failed"));
+ n_succeeded += good;
+ DB((dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, col, good ? "succeeded" : "failed"));
+ }
+
+ /* unfix all nodes */
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+ co_mst_irn_t *node = get_co_mst_irn(env, c->n[idx]);
+ node->fixed = 0;
}
/* try next color when failed */
- if (! one_good) {
- reject_coloring(&changed_ones);
+ if (n_succeeded == 0) {
+ del_waitq(good_starts);
continue;
}
if (local_best) {
aff_chunk_assure_weight(env, local_best);
- DB((dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
- DBG_AFF_CHUNK(env, LEVEL_4, local_best);
+ 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) {
best_chunk = local_best;
if (best_starts)
del_waitq(best_starts);
best_starts = good_starts;
- DB((dbg, LEVEL_4, "\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_4, "\n\t\t... omitting, global best is better\n"));
+ DB((dbg, LEVEL_3, "\n\t\t... omitting, global best is better\n"));
del_waitq(good_starts);
}
}
del_waitq(good_starts);
}
- reject_coloring(&changed_ones);
+ /* if all nodes were recolored, bail out */
+ if (n_succeeded == n_nodes)
+ break;
}
+ stat_ev_int("heur4_colors_tried", i);
+
/* free all intermediate created chunks except best one */
while (! waitq_empty(tmp_chunks)) {
- aff_chunk_t *tmp = waitq_get(tmp_chunks);
+ aff_chunk_t *tmp = (aff_chunk_t*)waitq_get(tmp_chunks);
if (tmp != best_chunk)
- delete_aff_chunk(env, tmp);
+ delete_aff_chunk(tmp);
}
del_waitq(tmp_chunks);
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));
- INIT_LIST_HEAD(&changed_ones);
for (idx = 0, len = ARR_LEN(best_chunk->n); idx < len; ++idx) {
- ir_node *irn = best_chunk->n[idx];
- co_mst_irn_t *node = get_co_mst_irn(env, irn);
- co_mst_irn_t *n, *temp;
+ const ir_node *irn = best_chunk->n[idx];
+ co_mst_irn_t *node = get_co_mst_irn(env, irn);
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));
- INIT_LIST_HEAD(&changed_ones);
- res = change_node_color(env, node, best_color, &changed_ones);
+ 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);
+ stat_ev_tim_pop("heur4_recolor");
if (res) {
- materialize_coloring(&changed_ones);
+ materialize_coloring(&changed);
node->fixed = 1;
}
+ assert(list_empty(&changed));
}
/* 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) {
- 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) {
- ir_node *n = c->n[idx];
- co_mst_irn_t *nn = get_co_mst_irn(env, n);
+ const ir_node *n = c->n[idx];
+ co_mst_irn_t *nn = get_co_mst_irn(env, n);
nn->chunk = c;
}
/* fragment the remaining chunk */
- visited = bitset_irg_malloc(env->co->irg);
- bitset_or(visited, best_chunk->nodes);
+ visited = bitset_malloc(get_irg_last_idx(env->co->irg));
+ 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) {
- ir_node *irn = c->n[idx];
+ const ir_node *irn = c->n[idx];
if (! bitset_is_set(visited, get_irn_idx(irn))) {
aff_chunk_t *new_chunk = new_aff_chunk(env);
co_mst_irn_t *node = get_co_mst_irn(env, irn);
}
}
+ for (idx = 0, len = ARR_LEN(best_chunk->n); idx < len; ++idx) {
+ const ir_node *n = best_chunk->n[idx];
+ co_mst_irn_t *nn = get_co_mst_irn(env, n);
+ nn->chunk = NULL;
+ }
+
/* clear obsolete chunks and free some memory */
- delete_aff_chunk(env, best_chunk);
+ delete_aff_chunk(best_chunk);
bitset_free(visited);
if (best_starts)
del_waitq(best_starts);
+
+ stat_ev_ctx_pop("heur4_color_chunk");
}
/**
* Main driver for mst safe coalescing algorithm.
*/
-int co_solve_heuristic_mst(copy_opt_t *co) {
- unsigned n_regs = co->cls->n_regs;
- bitset_t *ignore_regs = bitset_alloca(n_regs);
- unsigned k;
- ir_node *irn;
- co_mst_env_t mst_env;
-
- /* init phase */
- phase_init(&mst_env.ph, "co_mst", co->irg, PHASE_DEFAULT_GROWTH, co_mst_irn_init, &mst_env);
+static int co_solve_heuristic_mst(copy_opt_t *co)
+{
+ last_chunk_id = 0;
- k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs);
- k = n_regs - k;
+ stat_ev_tim_push();
- mst_env.n_regs = n_regs;
- mst_env.k = k;
- mst_env.chunks = new_pqueue();
- mst_env.co = co;
- mst_env.ignore_regs = ignore_regs;
- mst_env.ifg = co->cenv->ifg;
- mst_env.aenv = co->aenv;
- mst_env.chunkset = pset_new_ptr(512);
+ /* init phase */
+ co_mst_env_t mst_env;
+ ir_nodemap_init(&mst_env.map, co->irg);
+ obstack_init(&mst_env.obst);
+
+ unsigned const n_regs = co->cls->n_regs;
+
+ mst_env.n_regs = n_regs;
+ mst_env.chunks = new_pqueue();
+ mst_env.co = co;
+ mst_env.allocatable_regs = co->cenv->allocatable_regs;
+ mst_env.ifg = co->cenv->ifg;
+ INIT_LIST_HEAD(&mst_env.chunklist);
+ mst_env.chunk_visited = 0;
+ mst_env.single_cols = OALLOCN(&mst_env.obst, col_cost_t*, n_regs);
+
+ for (unsigned i = 0; i < n_regs; ++i) {
+ col_cost_t *vec = OALLOCN(&mst_env.obst, col_cost_t, n_regs);
+
+ mst_env.single_cols[i] = vec;
+ for (unsigned j = 0; j < n_regs; ++j) {
+ vec[j].col = j;
+ vec[j].cost = REAL(0.0);
+ }
+ vec[i].col = 0;
+ vec[0].col = i;
+ vec[0].cost = REAL(1.0);
+ }
DBG((dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
/* build affinity chunks */
+ stat_ev_tim_push();
build_affinity_chunks(&mst_env);
+ stat_ev_tim_pop("heur4_initial_chunk");
/* color chunks as long as there are some */
while (! pqueue_empty(mst_env.chunks)) {
- aff_chunk_t *chunk = pqueue_get(mst_env.chunks);
+ aff_chunk_t *chunk = (aff_chunk_t*)pqueue_pop_front(mst_env.chunks);
color_aff_chunk(&mst_env, chunk);
- DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%d) done\n", chunk->id));
- delete_aff_chunk(&mst_env, chunk);
+ DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%u) done\n", chunk->id));
+ delete_aff_chunk(chunk);
}
/* apply coloring */
- foreach_phase_irn(&mst_env.ph, irn) {
- co_mst_irn_t *mirn = get_co_mst_irn(&mst_env, irn);
+ for (size_t pn = 0; pn < ARR_LEN(mst_env.map.data); ++pn) {
+ co_mst_irn_t *mirn = (co_mst_irn_t*)mst_env.map.data[pn];
const arch_register_t *reg;
-
- if (arch_irn_is(mst_env.aenv, irn, ignore))
+ if (mirn == NULL)
+ continue;
+ ir_node *const irn = get_idx_irn(co->irg, pn);
+ if (arch_irn_is_ignore(irn))
continue;
-
- // assert(mirn->fixed && "Node should have fixed color");
/* skip nodes where color hasn't changed */
if (mirn->init_col == mirn->col)
continue;
reg = arch_register_for_index(co->cls, mirn->col);
- arch_set_irn_register(co->aenv, irn, reg);
+ arch_set_irn_register(irn, reg);
DB((dbg, LEVEL_1, "%+F set color from %d to %d\n", irn, mirn->init_col, mirn->col));
}
/* free allocated memory */
del_pqueue(mst_env.chunks);
- phase_free(&mst_env.ph);
- del_pset(mst_env.chunkset);
+ obstack_free(&mst_env.obst, NULL);
+ ir_nodemap_destroy(&mst_env.map);
+
+ stat_ev_tim_pop("heur4_total");
return 0;
}
-void be_init_copyheur4(void) {
+static const lc_opt_table_entry_t options[] = {
+ LC_OPT_ENT_INT ("limit", "limit recoloring", &recolor_limit),
+ LC_OPT_ENT_DBL ("di", "dislike influence", &dislike_influence),
+ LC_OPT_LAST
+};
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4)
+void be_init_copyheur4(void)
+{
+ lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
+ lc_opt_entry_t *ra_grp = lc_opt_get_grp(be_grp, "ra");
+ lc_opt_entry_t *chordal_grp = lc_opt_get_grp(ra_grp, "chordal");
+ lc_opt_entry_t *co_grp = lc_opt_get_grp(chordal_grp, "co");
+ lc_opt_entry_t *heur4_grp = lc_opt_get_grp(co_grp, "heur4");
+
+ static co_algo_info copyheur = {
+ co_solve_heuristic_mst, 0
+ };
+
+ lc_opt_add_table(heur4_grp, options);
+ be_register_copyopt("heur4", ©heur);
+
FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4");
}
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);
projects / libfirm / blobdiff