DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL);
-#define BE_SCHED_NODE(irn) (be_is_Keep(irn) || be_is_CopyKeep(irn) || be_is_RegParams(irn))
-
enum {
BE_SCHED_SELECT_TRIVIAL,
BE_SCHED_SELECT_REGPRESS,
BE_SCHED_PREP_RSS = 3
};
-typedef struct _list_sched_options_t {
+typedef struct list_sched_options_t {
int select; /**< the node selector */
int prep; /**< schedule preparation */
} list_sched_options_t;
/**
* All scheduling info needed per node.
*/
-typedef struct _sched_irn_t {
+typedef struct sched_irn_t {
unsigned num_not_sched_user; /**< The number of not yet scheduled users of this node */
unsigned already_sched : 1; /**< Set if this node is already scheduled */
} sched_irn_t;
/**
* Scheduling environment for the whole graph.
*/
-typedef struct _sched_env_t {
+typedef struct sched_env_t {
sched_irn_t *sched_info; /**< scheduling info per node */
const list_sched_selector_t *selector; /**< The node selector. */
void *selector_env; /**< A pointer to give to the selector. */
/**
* Environment for a block scheduler.
*/
-typedef struct _block_sched_env_t {
+typedef struct block_sched_env_t {
sched_irn_t *sched_info; /**< scheduling info per node, copied from the global scheduler object */
ir_nodeset_t cands; /**< the set of candidates */
ir_node *block; /**< the current block */
void *selector_block_env;
} block_sched_env_t;
-/**
- * Returns non-zero if a node must be placed in the schedule.
- */
-static inline int must_appear_in_schedule(const list_sched_selector_t *sel, void *block_env, const ir_node *irn)
-{
- int res = -1;
-
- /* if there are no uses, don't schedule */
- if (get_irn_n_edges(irn) < 1)
- return 0;
-
- /* else ask the scheduler */
- if (sel->to_appear_in_schedule)
- res = sel->to_appear_in_schedule(block_env, irn);
-
- return res >= 0 ? res : ((to_appear_in_schedule(irn) || BE_SCHED_NODE(irn)) && ! is_Unknown(irn));
-}
-
/**
* Returns non-zero if the node is already scheduled
*/
return 0;
}
- if (! must_appear_in_schedule(env->selector, env, irn)) {
+ if (! to_appear_in_schedule(irn)) {
add_to_sched(env, irn);
DB((dbg, LEVEL_3, "\tmaking immediately available: %+F\n", irn));
} else {
/**
* Returns the number of not yet schedules users.
*/
-static inline int get_irn_not_sched_user(block_sched_env_t *env, ir_node *n) {
+static inline int get_irn_not_sched_user(block_sched_env_t *env, ir_node *n)
+{
int idx = get_irn_idx(n);
assert(idx < ARR_LEN(env->sched_info));
/**
* Sets the number of not yet schedules users.
*/
-static inline void set_irn_not_sched_user(block_sched_env_t *env, ir_node *n, int num) {
+static inline void set_irn_not_sched_user(block_sched_env_t *env, ir_node *n, int num)
+{
int idx = get_irn_idx(n);
assert(idx < ARR_LEN(env->sched_info));
/**
* Add @p num to the number of not yet schedules users and returns the result.
*/
-static inline int add_irn_not_sched_user(block_sched_env_t *env, ir_node *n, int num) {
+static inline int add_irn_not_sched_user(block_sched_env_t *env, ir_node *n, int num)
+{
int idx = get_irn_idx(n);
assert(idx < ARR_LEN(env->sched_info));
/**
* Returns the number of users of a node having mode datab.
*/
-static int get_num_successors(ir_node *irn) {
+static int get_num_successors(ir_node *irn)
+{
int sum = 0;
const ir_edge_t *edge;
* Adds irn to @p live, updates all inputs that this user is scheduled
* and counts all of its non scheduled users.
*/
-static void update_sched_liveness(block_sched_env_t *env, ir_node *irn) {
+static void update_sched_liveness(block_sched_env_t *env, ir_node *irn)
+{
int i;
/* ignore Projs */
{
/* If the node consumes/produces data, it is appended to the schedule
* list, otherwise, it is not put into the list */
- if (must_appear_in_schedule(env->selector, env->selector_block_env, irn)) {
+ if (to_appear_in_schedule(irn)) {
update_sched_liveness(env, irn);
sched_add_before(env->block, irn);
DBG((dbg, LEVEL_2, "\tadding %+F\n", irn));
- /* Remove the node from the ready set */
+ /* Remove the node from the ready set */
ir_nodeset_remove(&env->cands, irn);
}
{
sched_env_t *env = env_ptr;
const list_sched_selector_t *selector = env->selector;
- ir_node *start_node = get_irg_start(get_irn_irg(block));
block_sched_env_t be;
const ir_edge_t *edge;
if (code == iro_End) {
/* Skip the end node because of keep-alive edges. */
continue;
- } else if (code == iro_Block) {
- /* A Block-Block edge. This should be the MacroBlock
- * edge, ignore it. */
- assert(get_Block_MacroBlock(irn) == block && "Block-Block edge found");
- continue;
}
users = get_irn_n_edges(irn);
if (is_Phi(irn)) {
/*
- Phi functions are scheduled immediately, since they only
- transfer data flow from the predecessors to this block.
+ Phi functions are scheduled immediately, since they only
+ transfer data flow from the predecessors to this block.
*/
add_to_sched(&be, irn);
- }
- else if (irn == start_node) {
+ } else if (be_is_Start(irn)) {
/* The start block will be scheduled as the first node */
add_to_sched(&be, irn);
- }
- else {
+ } else {
/* Other nodes must have all operands in other blocks to be made
* ready */
int ready = 1;
}
/* List schedule a graph. */
-void list_sched(be_irg_t *birg, be_options_t *be_opts)
+void list_sched(ir_graph *irg)
{
- ir_graph *irg = birg->irg;
-
int num_nodes;
sched_env_t env;
mris_env_t *mris = NULL;
- list_sched_selector_t sel;
-
- (void)be_opts;
+ const list_sched_selector_t *selector;
/* Select a scheduler based on backend options */
switch (list_sched_options.select) {
- case BE_SCHED_SELECT_TRIVIAL: sel = trivial_selector; break;
- case BE_SCHED_SELECT_RANDOM: sel = random_selector; break;
- case BE_SCHED_SELECT_REGPRESS: sel = reg_pressure_selector; break;
- case BE_SCHED_SELECT_MUCHNIK: sel = muchnik_selector; break;
- case BE_SCHED_SELECT_HEUR: sel = heuristic_selector; break;
- case BE_SCHED_SELECT_NORMAL: sel = normal_selector; break;
+ case BE_SCHED_SELECT_TRIVIAL: selector = &trivial_selector; break;
+ case BE_SCHED_SELECT_RANDOM: selector = &random_selector; break;
+ case BE_SCHED_SELECT_REGPRESS: selector = ®_pressure_selector; break;
+ case BE_SCHED_SELECT_MUCHNIK: selector = &muchnik_selector; break;
+ case BE_SCHED_SELECT_HEUR: selector = &heuristic_selector; break;
+ case BE_SCHED_SELECT_NORMAL: selector = &normal_selector; break;
default:
- case BE_SCHED_SELECT_HMUCHNIK: sel = heuristic_selector; break;
+ case BE_SCHED_SELECT_HMUCHNIK: selector = &heuristic_selector; break;
}
#if 1
switch (list_sched_options.prep) {
case BE_SCHED_PREP_MRIS:
- mris = be_sched_mris_preprocess(birg);
+ mris = be_sched_mris_preprocess(irg);
break;
case BE_SCHED_PREP_RSS:
- rss_schedule_preparation(birg);
+ rss_schedule_preparation(irg);
break;
default:
break;
/* initialize environment for list scheduler */
memset(&env, 0, sizeof(env));
- env.selector = arch_env_get_list_sched_selector(birg->main_env->arch_env, &sel);
+ env.selector = selector;
env.sched_info = NEW_ARR_F(sched_irn_t, num_nodes);
memset(env.sched_info, 0, num_nodes * sizeof(env.sched_info[0]));
if (env.selector->init_graph)
- env.selector_env = env.selector->init_graph(env.selector, birg);
+ env.selector_env = env.selector->init_graph(env.selector, irg);
/* Schedule each single block. */
irg_block_walk_graph(irg, list_sched_block, NULL, &env);
}
/* List schedule a block. */
-void list_sched_single_block(const be_irg_t *birg, ir_node *block,
- be_options_t *be_opts)
+void list_sched_single_block(ir_graph *irg, ir_node *block)
{
- ir_graph *irg = birg->irg;
-
int num_nodes;
sched_env_t env;
- list_sched_selector_t sel;
-
- (void)be_opts;
+ const list_sched_selector_t *selector;
/* Select a scheduler based on backend options */
switch (list_sched_options.select) {
- case BE_SCHED_SELECT_TRIVIAL: sel = trivial_selector; break;
- case BE_SCHED_SELECT_RANDOM: sel = random_selector; break;
- case BE_SCHED_SELECT_REGPRESS: sel = reg_pressure_selector; break;
- case BE_SCHED_SELECT_MUCHNIK: sel = muchnik_selector; break;
- case BE_SCHED_SELECT_HEUR: sel = heuristic_selector; break;
- case BE_SCHED_SELECT_NORMAL: sel = normal_selector; break;
+ case BE_SCHED_SELECT_TRIVIAL: selector = &trivial_selector; break;
+ case BE_SCHED_SELECT_RANDOM: selector = &random_selector; break;
+ case BE_SCHED_SELECT_REGPRESS: selector = ®_pressure_selector; break;
+ case BE_SCHED_SELECT_MUCHNIK: selector = &muchnik_selector; break;
+ case BE_SCHED_SELECT_HEUR: selector = &heuristic_selector; break;
+ case BE_SCHED_SELECT_NORMAL: selector = &normal_selector; break;
default:
- case BE_SCHED_SELECT_HMUCHNIK: sel = trivial_selector; break;
+ case BE_SCHED_SELECT_HMUCHNIK: selector = &trivial_selector; break;
}
/* Assure, that the out edges are computed */
/* initialize environment for list scheduler */
memset(&env, 0, sizeof(env));
- env.selector = arch_env_get_list_sched_selector(birg->main_env->arch_env, &sel);
+ env.selector = selector;
env.sched_info = NEW_ARR_F(sched_irn_t, num_nodes);
memset(env.sched_info, 0, num_nodes * sizeof(env.sched_info[0]));
if (env.selector->init_graph)
- env.selector_env = env.selector->init_graph(env.selector, birg);
+ env.selector_env = env.selector->init_graph(env.selector, irg);
/* Schedule block. */
list_sched_block(block, &env);
DEL_ARR_F(env.sched_info);
}
-/**
- * Register list scheduler options.
- */
-void be_init_listsched(void) {
- lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_listsched);
+void be_init_listsched(void)
+{
+ lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
lc_opt_entry_t *sched_grp = lc_opt_get_grp(be_grp, "listsched");
lc_opt_add_table(sched_grp, list_sched_option_table);
FIRM_DBG_REGISTER(dbg, "firm.be.sched");
}
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_listsched);