* @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.
#include "xmalloc.h"
#include "pdeq.h"
#include "irprintf.h"
-#include "irbitset.h"
+#include "util.h"
#include "irtools.h"
#include "error.h"
#include "list.h"
#include "statev.h"
-#include "irbitset.h"
-
#include "bearch.h"
#include "beifg.h"
#include "be_t.h"
static co_mst_irn_t *get_co_mst_irn(co_mst_env_t *env, const ir_node *node)
{
- co_mst_irn_t *res = (co_mst_irn_t*)ir_nodemap_get(&env->map, 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);
*/
static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node)
{
- size_t idx;
(void) env;
if (bitset_popcount(node->adm_colors) < 1)
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;
- return (diff > 0) - (diff < 0);
+
+ if (diff < 0)
+ return 1;
+ if (diff > 0)
+ return -1;
+
+ return QSORT_CMP(c1->col, c2->col);
}
static int cmp_col_cost_gt(const void *a, const void *b)
const col_cost_t *c2 = (const col_cost_t*)b;
real_t diff = c2->cost - c1->cost;
- if (diff == 0.0)
- return QSORT_CMP(c1->col, c2->col);
+ if (diff > 0)
+ return 1;
+ if (diff < 0)
+ return -1;
- return (diff > 0) - (diff < 0);
+ return QSORT_CMP(c1->col, c2->col);
}
/**
node->chunk = c;
if (node->constr_factor > REAL(0.0)) {
- size_t col;
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;
*/
static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an)
{
- const neighb_t *neigh;
const ir_node *irn = an->irn;
const co_mst_irn_t *node = get_co_mst_irn(env, irn);
int res = 0;
aff_edge_t *edges = NEW_ARR_F(aff_edge_t, 0);
ir_node *n;
int i, len;
- aff_chunk_t *curr_chunk;
size_t pn;
/* at first we create the affinity edge objects */
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);
}
for (pn = 0; pn < ARR_LEN(env->map.data); ++pn) {
- co_mst_irn_t *mirn = 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)
const ir_node *irn = chunk->n[--i];
affinity_node_t *an = get_affinity_info(env->co, irn);
int w = 0;
- neighb_t *neigh;
if (arch_irn_is_ignore(irn))
continue;
}
if (max_node) {
- bitset_t *visited = bitset_irg_malloc(env->co->irg);
+ bitset_t *visited = bitset_malloc(get_irg_last_idx(env->co->irg));
for (i = ARR_LEN(chunk->n); i != 0;)
- bitset_add_irn(visited, chunk->n[--i]);
+ bitset_set(visited, get_irn_idx(chunk->n[--i]));
pqueue_put(grow, (void *) max_node, max_weight);
- bitset_remv_irn(visited, max_node);
+ 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);
- neighb_t *neigh;
if (arch_irn_is_ignore(irn))
continue;
co_gs_foreach_neighb(an, neigh) {
co_mst_irn_t *node = get_co_mst_irn(env, neigh->irn);
- if (bitset_contains_irn(visited, node->irn)) {
+ if (bitset_is_set(visited, get_irn_idx(node->irn))) {
pqueue_put(grow, (void *) neigh->irn, neigh->costs);
- bitset_remv_irn(visited, node->irn);
+ bitset_clear(visited, get_irn_idx(node->irn));
}
}
}
/* check all affinity neighbors */
if (an != NULL) {
- neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
const 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);
+ bitset_t *visited = bitset_malloc(get_irg_last_idx(env->co->irg));
int idx, len;
aff_chunk_t *best = NULL;
*/
static inline void reject_coloring(struct list_head *nodes)
{
- co_mst_irn_t *n, *temp;
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));
static inline void materialize_coloring(struct list_head *nodes)
{
- co_mst_irn_t *n, *temp;
list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
assert(n->tmp_col >= 0);
n->col = n->tmp_col;
*/
for (i = 0; i < env->k; ++i) {
int col = order[i].col;
- waitq *good_starts = new_waitq();
+ waitq *good_starts;
aff_chunk_t *local_best;
int n_succeeded;
DB((dbg, LEVEL_2, "\ttrying color %d\n", col));
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) {
}
/* try next color when failed */
- if (n_succeeded == 0)
+ if (n_succeeded == 0) {
+ del_waitq(good_starts);
continue;
+ }
/* fragment the chunk according to the coloring */
local_best = fragment_chunk(env, col, c, tmp_chunks);
}
/* fragment the remaining chunk */
- visited = bitset_irg_malloc(env->co->irg);
+ 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]));
/* apply coloring */
for (pn = 0; pn < ARR_LEN(mst_env.map.data); ++pn) {
- co_mst_irn_t *mirn = 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 (mirn == NULL)
continue;
projects / libfirm / blobdiff