give Bad nodes a mode

[libfirm] / ir / be / beschedtrace.c

diff --git a/ir/be/beschedtrace.c b/ir/be/beschedtrace.c
index d336aaa..0a12e91 100644 (file)
--- a/ir/be/beschedtrace.c
+++ b/ir/be/beschedtrace.c
@@ -34,6 +34,7 @@
 #include "belistsched.h"
 #include "benode.h"
 #include "belive.h"
+#include "bemodule.h"
 
 /* we need a special mark */
 static char _mark;
@@ -52,8 +53,6 @@ typedef struct trace_irn {
 typedef struct trace_env {
        trace_irn_t      *sched_info;               /**< trace scheduling information about the nodes */
        sched_timestep_t curr_time;                 /**< current time of the scheduler */
-       void             *selector_env;             /**< the backend selector environment */
-       const list_sched_selector_t *selector;      /**< the actual backend selector */
        be_lv_t          *liveness;                 /**< The liveness for the irg */
        DEBUG_ONLY(firm_dbg_module_t *dbg;)
 } trace_env_t;
@@ -74,7 +73,7 @@ static ir_node *get_nodeset_node(const ir_nodeset_t *nodeset)
  */
 static inline unsigned is_root_node(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        return env->sched_info[idx].is_root;
@@ -85,7 +84,7 @@ static inline unsigned is_root_node(trace_env_t *env, ir_node *n)
  */
 static inline void mark_root_node(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        env->sched_info[idx].is_root = 1;
@@ -96,7 +95,7 @@ static inline void mark_root_node(trace_env_t *env, ir_node *n)
  */
 static inline sched_timestep_t get_irn_delay(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        return env->sched_info[idx].delay;
@@ -107,7 +106,7 @@ static inline sched_timestep_t get_irn_delay(trace_env_t *env, ir_node *n)
  */
 static inline void set_irn_delay(trace_env_t *env, ir_node *n, sched_timestep_t delay)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        env->sched_info[idx].delay = delay;
@@ -118,7 +117,7 @@ static inline void set_irn_delay(trace_env_t *env, ir_node *n, sched_timestep_t
  */
 static inline sched_timestep_t get_irn_etime(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        return env->sched_info[idx].etime;
@@ -129,7 +128,7 @@ static inline sched_timestep_t get_irn_etime(trace_env_t *env, ir_node *n)
  */
 static inline void set_irn_etime(trace_env_t *env, ir_node *n, sched_timestep_t etime)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        env->sched_info[idx].etime = etime;
@@ -140,7 +139,7 @@ static inline void set_irn_etime(trace_env_t *env, ir_node *n, sched_timestep_t
  */
 static inline unsigned get_irn_num_user(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        return env->sched_info[idx].num_user;
@@ -151,7 +150,7 @@ static inline unsigned get_irn_num_user(trace_env_t *env, ir_node *n)
  */
 static inline void set_irn_num_user(trace_env_t *env, ir_node *n, unsigned num_user)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        env->sched_info[idx].num_user = num_user;
@@ -162,7 +161,7 @@ static inline void set_irn_num_user(trace_env_t *env, ir_node *n, unsigned num_u
  */
 static inline int get_irn_reg_diff(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        return env->sched_info[idx].reg_diff;
@@ -173,7 +172,7 @@ static inline int get_irn_reg_diff(trace_env_t *env, ir_node *n)
  */
 static inline void set_irn_reg_diff(trace_env_t *env, ir_node *n, int reg_diff)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        env->sched_info[idx].reg_diff = reg_diff;
@@ -184,7 +183,7 @@ static inline void set_irn_reg_diff(trace_env_t *env, ir_node *n, int reg_diff)
  */
 static inline int get_irn_preorder(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        return env->sched_info[idx].preorder;
@@ -195,7 +194,7 @@ static inline int get_irn_preorder(trace_env_t *env, ir_node *n)
  */
 static inline void set_irn_preorder(trace_env_t *env, ir_node *n, int pos)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        env->sched_info[idx].preorder = pos;
@@ -206,7 +205,7 @@ static inline void set_irn_preorder(trace_env_t *env, ir_node *n, int pos)
  */
 static inline unsigned get_irn_critical_path_len(trace_env_t *env, ir_node *n)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        return env->sched_info[idx].critical_path_len;
@@ -217,7 +216,7 @@ static inline unsigned get_irn_critical_path_len(trace_env_t *env, ir_node *n)
  */
 static inline void set_irn_critical_path_len(trace_env_t *env, ir_node *n, unsigned len)
 {
-       int idx = get_irn_idx(n);
+       unsigned const idx = get_irn_idx(n);
 
        assert(idx < ARR_LEN(env->sched_info));
        env->sched_info[idx].critical_path_len = len;
@@ -228,10 +227,13 @@ static inline void set_irn_critical_path_len(trace_env_t *env, ir_node *n, unsig
  */
 static sched_timestep_t exectime(trace_env_t *env, ir_node *n)
 {
+       (void) env;
        if (be_is_Keep(n) || is_Proj(n))
                return 0;
+#if 0
        if (env->selector->exectime)
                return env->selector->exectime(env->selector_env, n);
+#endif
        return 1;
 }
 
@@ -240,6 +242,8 @@ static sched_timestep_t exectime(trace_env_t *env, ir_node *n)
  */
 static sched_timestep_t latency(trace_env_t *env, ir_node *pred, int pred_cycle, ir_node *curr, int curr_cycle)
 {
+       (void) pred_cycle;
+       (void) curr_cycle;
        /* a Keep hides a root */
        if (be_is_Keep(curr))
                return exectime(env, pred);
@@ -252,8 +256,11 @@ static sched_timestep_t latency(trace_env_t *env, ir_node *pred, int pred_cycle,
        if (is_Proj(pred))
                pred = get_Proj_pred(pred);
 
+#if 0
        if (env->selector->latency)
                return env->selector->latency(env->selector_env, pred, pred_cycle, curr, curr_cycle);
+#endif
+
        return 1;
 }
 
@@ -563,14 +570,13 @@ static ir_node *basic_selection(ir_nodeset_t *ready_set)
 /**
 * The muchnik selector.
 */
-static ir_node *muchnik_select(void *block_env, ir_nodeset_t *ready_set, ir_nodeset_t *live_set)
+static ir_node *muchnik_select(void *block_env, ir_nodeset_t *ready_set)
 {
        trace_env_t *env = (trace_env_t*)block_env;
        ir_nodeset_t mcands, ecands;
        ir_nodeset_iterator_t iter;
        sched_timestep_t max_delay = 0;
        ir_node *irn;
-       (void) live_set;
 
        /* calculate the max delay of all candidates */
        foreach_ir_nodeset(ready_set, irn, iter) {
@@ -621,11 +627,9 @@ force_mcands:
        return irn;
 }
 
-static void *muchnik_init_graph(const list_sched_selector_t *vtab, ir_graph *irg)
+static void *muchnik_init_graph(ir_graph *irg)
 {
        trace_env_t *env  = trace_init(irg);
-       env->selector     = vtab;
-       env->selector_env = (void*) be_get_irg_arch_env(irg);
        return (void *)env;
 }
 
@@ -636,30 +640,35 @@ static void *muchnik_init_block(void *graph_env, ir_node *bl)
        return graph_env;
 }
 
-const list_sched_selector_t muchnik_selector = {
-       muchnik_init_graph,
-       muchnik_init_block,
-       muchnik_select,
-       trace_node_ready,    /* node_ready */
-       trace_update_time,   /* node_selected */
-       NULL,                /* exectime */
-       NULL,                /* latency */
-       NULL,                /* finish_block */
-       trace_free           /* finish_graph */
-};
+static void sched_muchnik(ir_graph *irg)
+{
+       static const list_sched_selector_t muchnik_selector = {
+               muchnik_init_graph,
+               muchnik_init_block,
+               muchnik_select,
+               trace_node_ready,    /* node_ready */
+               trace_update_time,   /* node_selected */
+               NULL,                /* finish_block */
+               trace_free           /* finish_graph */
+       };
+       be_list_sched_graph(irg, &muchnik_selector);
+}
 
 /**
  * Execute the heuristic function.
  */
-static ir_node *heuristic_select(void *block_env, ir_nodeset_t *ns, ir_nodeset_t *lv)
+static ir_node *heuristic_select(void *block_env, ir_nodeset_t *ns)
 {
        trace_env_t *trace_env   = (trace_env_t*)block_env;
        ir_node     *irn, *cand  = NULL;
        int         max_prio     = INT_MIN;
        int         cur_prio     = INT_MIN;
-       int         cur_pressure = ir_nodeset_size(lv);
        int         reg_fact, cand_reg_fact;
        ir_nodeset_iterator_t iter;
+       /* Note: register pressure calculation needs an overhaul, you need correct
+        * tracking for each register class indidually and weight by each class
+       int         cur_pressure = ir_nodeset_size(lv); */
+       int         cur_pressure = 1;
 
        /* prefer instructions which can be scheduled early */
 #define PRIO_TIME        3
@@ -682,7 +691,6 @@ static ir_node *heuristic_select(void *block_env, ir_nodeset_t *ns, ir_nodeset_t
                        int sign  = rdiff < 0;
                        int chg   = (rdiff < 0 ? -rdiff : rdiff) << PRIO_CHG_PRESS;
 
-                       /* reg_fact = chg << cur_pressure; */
                        reg_fact = chg * cur_pressure;
                        if (reg_fact < chg)
                                reg_fact = INT_MAX - 2;
@@ -723,14 +731,23 @@ static ir_node *heuristic_select(void *block_env, ir_nodeset_t *ns, ir_nodeset_t
        return cand;
 }
 
-const list_sched_selector_t heuristic_selector = {
-       muchnik_init_graph,
-       muchnik_init_block,
-       heuristic_select,
-       trace_node_ready,    /* node_ready */
-       trace_update_time,   /* node_selected */
-       NULL,                /* exectime */
-       NULL,                /* latency */
-       NULL,                /* finish_block */
-       trace_free           /* finish_graph */
-};
+static void sched_heuristic(ir_graph *irg)
+{
+       static const list_sched_selector_t heuristic_selector = {
+               muchnik_init_graph,
+               muchnik_init_block,
+               heuristic_select,
+               trace_node_ready,    /* node_ready */
+               trace_update_time,   /* node_selected */
+               NULL,                /* finish_block */
+               trace_free           /* finish_graph */
+       };
+       be_list_sched_graph(irg, &heuristic_selector);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_sched_trace)
+void be_init_sched_trace(void)
+{
+       be_register_scheduler("heur", sched_heuristic);
+       be_register_scheduler("muchnik", sched_muchnik);
+}