#include "raw_bitset.h"
#include "irphase_t.h"
#include "pqueue.h"
-#include "pset_new.h"
#include "xmalloc.h"
#include "pdeq.h"
+#include "pset.h"
#include "irprintf.h"
#include "irbitset.h"
#include "error.h"
* An affinity chunk.
*/
typedef struct _aff_chunk_t {
- ir_node **n;
+ 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 */
aff_chunk_t *c = xmalloc(sizeof(*c));
c->weight = -1;
c->weight_consistent = 0;
- c->n = NEW_ARR_F(ir_node *, 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++;
* 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) {
-#if 1
- if (bitset_is_set(chunk->interfere, get_irn_idx(irn)))
- return 1;
-#else
- const co_mst_irn_t *node = get_co_mst_irn(env, irn);
- const ir_node *neigh;
- int i;
-
- for (i = 0; i < node->n_neighs; ++i) {
- neigh = node->int_neighs[i];
- if (! arch_irn_is(env->aenv, neigh, ignore) && bitset_is_set(chunk->nodes, get_irn_idx(neigh)))
- return 1;
- }
-#endif
- return 0;
+ return bitset_is_set(chunk->interfere, get_irn_idx(irn));
}
/**
* @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) {
- int idx;
bitset_t *tmp;
if (c1 == c2)
return 0;
-#if 1
+
+ /* 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);
- if (bitset_popcnt(tmp) > 0)
- return 1;
-#else
- /* check if there is a node in c2 having an interfering neighbor in c1 */
- bitset_foreach(c2->nodes, idx) {
- ir_node *n = get_idx_irn(env->co->irg, idx);
- if (aff_chunk_interferes(env, c1, n))
- return 1;
- }
-#endif
- return 0;
+ return bitset_popcnt(tmp) > 0;
}
/**
goto absorbed;
}
} else if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
- int idx;
-
- bitset_or(c1->nodes, c2->nodes);
- bitset_or(c1->interfere, c2->interfere);
- c1->weight_consistent = 0;
+ int idx, len;
-// bitset_foreach(c2->nodes, idx) {
- for (idx = 0; idx < ARR_LEN(c2->n); ++idx) {
- int i;
-// ir_node *n = get_idx_irn(env->co->irg, idx);
+ 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);
+
mn->chunk = c1;
- for (i = 0; i < ARR_LEN(c1->n); ++i) {
- if (c1->n[i] == n)
- break;
- }
- if (i >= ARR_LEN(c1->n))
+ if (! bitset_is_set(c1->nodes, get_irn_idx(n)))
ARR_APP1(ir_node *, c1->n, n);
}
+ bitset_or(c1->nodes, c2->nodes);
+ bitset_or(c1->interfere, c2->interfere);
+ c1->weight_consistent = 0;
+
delete_aff_chunk(env, c2);
goto absorbed;
}
static void aff_chunk_assure_weight(const co_mst_env_t *env, aff_chunk_t *c) {
if (! c->weight_consistent) {
int w = 0;
- int idx;
+ int idx, len;
-// bitset_foreach(c->nodes, idx) {
-// ir_node *n = get_idx_irn(env->co->irg, idx);
- for (idx = 0; idx < ARR_LEN(c->n); ++idx) {
- ir_node *n = c->n[idx];
+ 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);
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;
+ const int m_idx = get_irn_idx(m);
/* skip ignore nodes */
if (arch_irn_is(env->aenv, m, ignore))
ir_node *n;
int i, len;
aff_chunk_t *curr_chunk;
- pset_new_iterator_t iter;
/* at first we create the affinity edge objects */
be_ifg_foreach_node(env->ifg, nodes_it, n) {
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);
*/
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);
- int idx;
+ int idx, len;
aff_chunk_t *best = NULL;
-// bitset_foreach(c->nodes, idx) {
- for (idx = 0; idx < ARR_LEN(c->n); ++idx) {
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
ir_node *irn;
co_mst_irn_t *node;
aff_chunk_t *tmp_chunk;
decide_func_t *decider;
int check_for_best;
- irn = c->n[idx];
+ irn = c->n[idx];
if (bitset_is_set(visited, get_irn_idx(irn)))
continue;
-// irn = get_idx_irn(env->co->irg, idx);
node = get_co_mst_irn(env, irn);
if (get_mst_irn_col(node) == col) {
static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
aff_chunk_t *best_chunk = NULL;
int best_color = -1;
- int best_node = -1;
waitq *changed_ones = new_waitq();
waitq *tmp_chunks = new_waitq();
waitq *best_starts = NULL;
bitset_t *visited;
- int col, idx;
+ int col, idx, len;
DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
DBG_AFF_CHUNK(env, LEVEL_2, c);
DB((dbg, LEVEL_3, "\ttrying color %d\n", col));
/* try to bring all nodes of given chunk to the current color. */
-// bitset_foreach(c->nodes, idx) {
-// ir_node *irn = get_idx_irn(env->co->irg, idx);
- for (idx = 0; idx < ARR_LEN(c->n); ++idx) {
+ 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;
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);
if (good)
waitq_put(good_starts, node);
del_waitq(good_starts);
}
}
+ else {
+ del_waitq(good_starts);
+ }
/* reject the coloring and bring the coloring to the initial state */
reject_coloring(changed_ones);
/* return if coloring failed */
if (! best_chunk) {
del_waitq(changed_ones);
+ if (best_starts)
+ del_waitq(best_starts);
return;
}
DB((dbg, LEVEL_2, "using color %d\n", best_color));
/* get the best fragment from the best list and color it */
-// bitset_foreach(best_chunk->nodes, idx) {
-// ir_node *irn = get_idx_irn(env->co->irg, idx);
while (! waitq_empty(best_starts)) {
co_mst_irn_t *node = waitq_get(best_starts);
int res;
node->fixed = 1;
node->chunk = best_chunk;
}
- for (idx = 0; idx < ARR_LEN(best_chunk->n); ++idx) {
- ir_node *irn = best_chunk->n[idx];
+ /* we colored the successful start nodes, now color the rest of the chunk */
+ 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);
int res;
/* remove the nodes in best chunk from original chunk */
bitset_andnot(c->nodes, best_chunk->nodes);
- {
- ir_node **tmp = NEW_ARR_F(ir_node *, 0);
- for (idx = 0; idx < ARR_LEN(c->n); ++idx) {
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
ir_node *irn = c->n[idx];
- int j;
- for (j = 0; j < ARR_LEN(best_chunk->n); ++j) {
- if (best_chunk->n[j] == irn)
- break;
+ if (bitset_is_set(best_chunk->nodes, get_irn_idx(irn))) {
+ int last = ARR_LEN(c->n) - 1;
+
+ c->n[idx] = c->n[last];
+ ARR_SHRINKLEN(c->n, last);
+ len--;
}
- if (j >= ARR_LEN(best_chunk->n))
- ARR_APP1(ir_node *, tmp, irn);
- }
- DEL_ARR_F(c->n);
- c->n = tmp;
}
/* we have to get the nodes back into the original chunk because they are scattered over temporary chunks */
-// bitset_foreach(c->nodes, idx) {
-// ir_node *n = get_idx_irn(env->co->irg, idx);
- for (idx = 0; idx < ARR_LEN(c->n); ++idx) {
- ir_node *n = c->n[idx];
+ 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);
nn->chunk = c;
}
/* fragment the remaining chunk */
visited = bitset_irg_malloc(env->co->irg);
bitset_or(visited, best_chunk->nodes);
-// bitset_foreach(c->nodes, idx) {
- for (idx = 0; idx < ARR_LEN(c->n); ++idx) {
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
ir_node *irn = c->n[idx];
if (! bitset_is_set(visited, get_irn_idx(irn))) {
aff_chunk_t *new_chunk = new_aff_chunk(env);
-// ir_node *irn = get_idx_irn(env->co->irg, idx);
co_mst_irn_t *node = get_co_mst_irn(env, irn);
expand_chunk_from(env, node, visited, new_chunk, c, decider_always_yes, 0);
delete_aff_chunk(env, best_chunk);
bitset_free(visited);
del_waitq(changed_ones);
+ if (best_starts)
+ del_waitq(best_starts);
}
/**
projects / libfirm / blobdiff