optimize next_use calculation (quadratic in number of outs not number of nodes in...

[r14380]

diff --git a/ir/be/bemain.c b/ir/be/bemain.c
index e4af781..0b4f639 100644 (file)
--- a/ir/be/bemain.c
+++ b/ir/be/bemain.c
@@ -314,8 +314,8 @@ static void initialize_birg(be_irg_t *birg, ir_graph *irg, be_main_env_t *env)
        /* Normalize proj nodes. */
        normalize_proj_nodes(irg);
 
-       /* create multiple return nodes */
-       /* TODO: find out why this does nothing */
+       /* we do this before critical edge split. As this produces less returns,
+          because sometimes (= 164.gzip) multiple returns are slower */
        normalize_n_returns(irg);
 
        /* Remove critical edges */
@@ -328,6 +328,8 @@ static void initialize_birg(be_irg_t *birg, ir_graph *irg, be_main_env_t *env)
        be_phi_handler_reset(env->phi_handler);
 
        set_irg_phase_state(irg, phase_backend);
+
+       dump(DUMP_INITIAL, irg, "-prepared", dump_ir_block_graph);
 }
 
 #define BE_TIMER_PUSH(timer)                                                        \

diff --git a/ir/be/bespillbelady.c b/ir/be/bespillbelady.c
index 6b6c660..948bbe4 100644 (file)
--- a/ir/be/bespillbelady.c
+++ b/ir/be/bespillbelady.c
@@ -716,6 +716,8 @@ void be_spill_belady_spill_env(be_irg_t *birg, const arch_register_class_t *cls,
                construct_cf_backedges(irg);
        }
 
+       be_clear_links(irg);
+
        /* init belady env */
        obstack_init(&env.ob);
        env.arch      = birg->main_env->arch_env;
@@ -731,7 +733,6 @@ void be_spill_belady_spill_env(be_irg_t *birg, const arch_register_class_t *cls,
                env.senv = spill_env;
        }
 
-       be_clear_links(irg);
        /* Decide which phi nodes will be spilled and place copies for them into the graph */
        irg_block_walk_graph(irg, compute_live_ins, NULL, &env);
        /* Fix high register pressure with belady algorithm */

diff --git a/ir/be/beuses.c b/ir/be/beuses.c
index f4d802c..eb9b536 100644 (file)
--- a/ir/be/beuses.c
+++ b/ir/be/beuses.c
@@ -159,18 +159,65 @@ static int be_is_phi_argument(const be_lv_t *lv, const ir_node *block, const ir_
        return 0;
 }
 
+static inline
+unsigned get_step(const ir_node *node)
+{
+       return PTR_TO_INT(get_irn_link(node));
+}
+
 static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                                                                  unsigned from_step, const ir_node *def,
                                                                  int skip_from_uses)
 {
-       unsigned step = from_step;
-       ir_node *block = get_nodes_block(from);
-       ir_node *node;
+       unsigned  step = from_step;
+       ir_node  *block = get_nodes_block(from);
+       ir_node  *next_use;
+       ir_node  *node;
+       unsigned  timestep;
+       int      next_use_step;
        const ir_edge_t *edge;
 
+#if 1
+       assert(skip_from_uses == 0 || skip_from_uses == 1);
+       if(skip_from_uses) {
+               from = sched_next(from);
+       }
+
+       next_use      = NULL;
+       next_use_step = INT_MAX;
+       timestep      = get_step(from);
+       foreach_out_edge(def, edge) {
+               ir_node  *node = get_edge_src_irn(edge);
+               unsigned  node_step;
+
+               if(get_nodes_block(node) != block)
+                       continue;
+               if(is_Phi(node))
+                       continue;
+
+               node_step = get_step(node);
+               if(node_step < timestep)
+                       continue;
+               if(node_step < next_use_step) {
+                       next_use      = node;
+                       next_use_step = node_step;
+               }
+       }
+
+       if(next_use != NULL) {
+               be_next_use_t result;
+               result.time           = next_use_step - timestep + skip_from_uses;
+               result.outermost_loop = get_loop_depth(get_irn_loop(block));
+               return result;
+       }
+
+       node = sched_last(block);
+       step = get_step(node) + 1 + timestep + skip_from_uses;
+
+#else
        if(skip_from_uses) {
-               step++;
                from = sched_next(from);
+               ++step;
        }
 
        sched_foreach_from(from, node) {
@@ -206,6 +253,7 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
 
                step++;
        }
+#endif
 
        if(be_is_phi_argument(env->lv, block, def)) {
                // TODO we really should continue searching the uses of the phi,
@@ -213,21 +261,21 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                // easily spill the whole phi)
 
                be_next_use_t result;
-               result.time = step;
+               result.time           = step;
                result.outermost_loop = get_loop_depth(get_irn_loop(block));
                return result;
        }
 
 #ifdef SCAN_INTERBLOCK_USES
        {
-       unsigned next_use = USES_INFINITY;
+       unsigned next_use   = USES_INFINITY;
        int outermost_loop;
        be_next_use_t result;
-       ir_loop *loop = get_irn_loop(block);
-       int loopdepth = get_loop_depth(loop);
-       int found_visited = 0;
-       int found_use = 0;
-       ir_graph *irg = get_irn_irg(block);
+       ir_loop *loop       = get_irn_loop(block);
+       int loopdepth       = get_loop_depth(loop);
+       int found_visited   = 0;
+       int found_use       = 0;
+       ir_graph *irg       = get_irn_irg(block);
        ir_node *startblock = get_irg_start_block(irg);
 
        outermost_loop = loopdepth;
@@ -301,12 +349,33 @@ be_next_use_t be_get_next_use(be_uses_t *env, ir_node *from,
        return get_next_use(env, from, from_step, def, skip_from_uses);
 }
 
+static
+void set_sched_step_walker(ir_node *block, void *data)
+{
+       ir_node  *node;
+       unsigned step = 0;
+
+       sched_foreach(block, node) {
+               set_irn_link(node, INT_TO_PTR(step));
+               if(is_Phi(node))
+                       continue;
+               if(is_Proj(node))
+                       continue;
+               ++step;
+       }
+}
+
 be_uses_t *be_begin_uses(ir_graph *irg, const be_lv_t *lv)
 {
        be_uses_t *env = xmalloc(sizeof(env[0]));
 
        edges_assure(irg);
 
+       //set_using_irn_link(irg);
+
+       /* precalculate sched steps */
+       irg_block_walk_graph(irg, set_sched_step_walker, NULL, NULL);
+
        env->uses = new_set(cmp_use, 512);
        env->irg = irg;
        env->lv = lv;
@@ -318,6 +387,7 @@ be_uses_t *be_begin_uses(ir_graph *irg, const be_lv_t *lv)
 
 void be_end_uses(be_uses_t *env)
 {
+       //clear_using_irn_link(env->irg);
        del_set(env->uses);
        free(env);
 }

diff --git a/ir/be/beutil.c b/ir/be/beutil.c
index ee4506c..8b66eef 100644 (file)
--- a/ir/be/beutil.c
+++ b/ir/be/beutil.c
@@ -191,7 +191,9 @@ static void collect_phis(ir_node *irn, void *data)
 
 void be_clear_links(ir_graph *irg)
 {
+       set_using_irn_link(irg);
        irg_walk_graph(irg, firm_clear_link, NULL, NULL);
+       clear_using_irn_link(irg);
 }
 
 void be_collect_phis(ir_graph *irg)

diff --git a/ir/be/test/queens-handoptimized.c b/ir/be/test/queens-handoptimized.c
index 095dd15..0f71a4a 100644 (file)
--- a/ir/be/test/queens-handoptimized.c
+++ b/ir/be/test/queens-handoptimized.c
@@ -23,12 +23,10 @@ typedef int boolean;
 #define true   1
 #define false  0
 
-#define static
-
 //static int *row;
 // queen in column c is at row[c]
 
-static inline int myabs(int i) {
+static int myabs(int i) {
     if(0 > i)
         i = -i;
     return(i);