* @author Sebastian Hack
* @cvs-id $Id$
*/
-
#ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
#endif
#include <stdio.h>
#include "debug.h"
#include "irtools.h"
+#include "bemodule.h"
#include "besched_t.h"
#include "beutil.h"
#include "belive_t.h"
#include "bearch.h"
#include "bestat.h"
-#ifdef WITH_LIBCORE
#include <libcore/lc_opts.h>
#include <libcore/lc_opts_enum.h>
-#endif /* WITH_LIBCORE */
+
+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 = 0,
BE_SCHED_PREP_NONE, /* no scheduling preparation */
};
-#ifdef WITH_LIBCORE
/* schedule selector options. */
static const lc_opt_enum_int_items_t sched_select_items[] = {
{ "trivial", BE_SCHED_SELECT_TRIVIAL },
};
static const lc_opt_table_entry_t list_sched_option_table[] = {
- LC_OPT_ENT_ENUM_PTR("prep", "schedule preparation (none, mris, rss)", &sched_prep_var),
- LC_OPT_ENT_ENUM_PTR("select", "node selector (trivial, random, regpress, muchnik, heur, hmuchnik)", &sched_select_var),
+ LC_OPT_ENT_ENUM_PTR("prep", "schedule preparation", &sched_prep_var),
+ LC_OPT_ENT_ENUM_PTR("select", "node selector", &sched_select_var),
{ NULL }
};
-#endif /* WITH_LIBCORE */
/**
* All scheduling info needed per node.
*/
typedef struct _block_sched_env_t {
sched_irn_t *sched_info; /**< scheduling info per node, copied from the global scheduler object */
- nodeset *cands; /**< the set of candidates */
+ ir_nodeset_t cands; /**< the set of candidates */
ir_node *block; /**< the current block */
sched_env_t *sched_env; /**< the scheduler environment */
- nodeset *live; /**< simple liveness during scheduling */
+ ir_nodeset_t live; /**< simple liveness during scheduling */
const list_sched_selector_t *selector;
void *selector_block_env;
- DEBUG_ONLY(firm_dbg_module_t *dbg;)
} block_sched_env_t;
/**
{
int i, n;
- /* Blocks cannot be scheduled. */
- if (is_Block(irn))
- return 0;
+ /* Blocks cannot be scheduled. */
+ if (is_Block(irn) || get_irn_n_edges(irn) == 0)
+ return 0;
- /*
- * Check, if the given ir node is in a different block as the
- * currently scheduled one. If that is so, don't make the node ready.
- */
- if (env->block != get_nodes_block(irn))
- return 0;
+ /*
+ * Check, if the given ir node is in a different block as the
+ * currently scheduled one. If that is so, don't make the node ready.
+ */
+ if (env->block != get_nodes_block(irn))
+ return 0;
for (i = 0, n = get_irn_ins_or_deps(irn); i < n; ++i) {
- ir_node *op = get_irn_in_or_dep(irn, i);
-
- /* if irn is an End we have keep-alives and op might be a block, skip that */
- if (is_Block(op)) {
- assert(get_irn_op(irn) == op_End);
- continue;
- }
-
- /* If the operand is local to the scheduled block and not yet
- * scheduled, this nodes cannot be made ready, so exit. */
- if (! is_already_scheduled(env, op) && get_nodes_block(op) == env->block)
- return 0;
- }
+ ir_node *op = get_irn_in_or_dep(irn, i);
+
+ /* if irn is an End we have keep-alives and op might be a block, skip that */
+ if (is_Block(op)) {
+ assert(get_irn_op(irn) == op_End);
+ continue;
+ }
+
+ /* If the operand is local to the scheduled block and not yet
+ * scheduled, this nodes cannot be made ready, so exit. */
+ if (! is_already_scheduled(env, op) && get_nodes_block(op) == env->block)
+ return 0;
+ }
- nodeset_insert(env->cands, irn);
+ ir_nodeset_insert(&env->cands, irn);
/* Notify selector about the ready node. */
if (env->selector->node_ready)
env->selector->node_ready(env->selector_block_env, irn, pred);
- DB((env->dbg, LEVEL_2, "\tmaking ready: %+F\n", irn));
+ DB((dbg, LEVEL_2, "\tmaking ready: %+F\n", irn));
return 1;
}
/**
* Try, to make all users of a node ready.
* In fact, a usage node can only be made ready, if all its operands
- * have already been scheduled yet. This is checked my make_ready().
+ * have already been scheduled yet. This is checked by make_ready().
* @param env The block schedule environment.
* @param irn The node, which usages (successors) are to be made ready.
*/
in = get_Proj_pred(in);
/* if in is still in the live set: reduce number of users by one */
- if (nodeset_find(env->live, in)) {
+ if (ir_nodeset_contains(&env->live, in)) {
if (add_irn_not_sched_user(env, in, -1) <= 0)
- nodeset_remove(env->live, in);
+ ir_nodeset_remove(&env->live, in);
}
}
i = get_num_successors(irn);
if (i > 0) {
set_irn_not_sched_user(env, irn, i);
- nodeset_insert(env->live, irn);
+ ir_nodeset_insert(&env->live, irn);
}
}
{
int res = -1;
- if(sel->to_appear_in_schedule)
+ if (get_irn_n_edges(irn) < 1)
+ return 0;
+
+ 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_is_Keep(irn) || be_is_CopyKeep(irn) || be_is_RegParams(irn));
+ return res >= 0 ? res : ((to_appear_in_schedule(irn) || BE_SCHED_NODE(irn)) && ! is_Unknown(irn));
}
/**
/* 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)) {
- sched_info_t *info = get_irn_sched_info(irn);
- INIT_LIST_HEAD(&info->list);
- info->scheduled = 1;
update_sched_liveness(env, irn);
sched_add_before(env->block, irn);
- DBG((env->dbg, LEVEL_2, "\tadding %+F\n", irn));
+ DBG((dbg, LEVEL_2, "\tadding %+F\n", irn));
}
/* notify the selector about the finally selected node. */
mark_already_scheduled(env, irn);
/* Remove the node from the ready set */
- if(nodeset_find(env->cands, irn))
- nodeset_remove(env->cands, irn);
+ ir_nodeset_remove(&env->cands, irn);
return irn;
}
assert(get_irn_mode(irn) == mode_T && "Mode of node must be tuple");
- if(is_Bad(irn))
+ if (is_Bad(irn))
return;
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));
- sched_info_t *info = get_irn_sched_info(block);
block_sched_env_t be;
const ir_edge_t *edge;
int j, m;
/* Initialize the block's list head that will hold the schedule. */
- INIT_LIST_HEAD(&info->list);
+ sched_init_block(block);
/* Initialize the block scheduling environment */
be.sched_info = env->sched_info;
be.block = block;
- be.cands = new_nodeset(get_irn_n_edges(block));
- be.live = new_nodeset(get_irn_n_edges(block));
+ ir_nodeset_init_size(&be.cands, get_irn_n_edges(block));
+ ir_nodeset_init_size(&be.live, get_irn_n_edges(block));
be.selector = selector;
be.sched_env = env;
- FIRM_DBG_REGISTER(be.dbg, "firm.be.sched");
- DBG((be.dbg, LEVEL_1, "scheduling %+F\n", block));
+ DBG((dbg, LEVEL_1, "scheduling %+F\n", block));
if (selector->init_block)
be.selector_block_env = selector->init_block(env->selector_env, block);
if (get_irn_opcode(irn) == iro_End)
continue;
+ if (get_irn_n_edges(irn) == 0)
+ continue;
+
if (is_Phi(irn)) {
/*
Phi functions are scheduled immediately, since they only
/* Make the node ready, if all operands live in a foreign block */
if (ready) {
- DBG((be.dbg, LEVEL_2, "\timmediately ready: %+F\n", irn));
+ DBG((dbg, LEVEL_2, "\timmediately ready: %+F\n", irn));
make_ready(&be, NULL, irn);
}
}
}
/* Iterate over all remaining nodes */
- while (nodeset_count(be.cands) > 0) {
+ while (ir_nodeset_size(&be.cands) > 0) {
+ ir_nodeset_iterator_t iter;
/* collect statistics about amount of ready nodes */
- be_do_stat_sched_ready(block, be.cands);
+ be_do_stat_sched_ready(block, &be.cands);
/* Keeps must be scheduled immediatly */
- foreach_nodeset(be.cands, irn) {
- if (be_is_Keep(irn) || be_is_CopyKeep(irn) || get_irn_mode(irn) == mode_M) {
- nodeset_break(be.cands);
+ foreach_ir_nodeset(&be.cands, irn, iter) {
+ if (be_is_Keep(irn) || be_is_CopyKeep(irn) || is_Sync(irn)) {
break;
}
}
if (! irn) {
/* Keeps must be immediately scheduled */
- irn = be.selector->select(be.selector_block_env, be.cands, be.live);
+ irn = be.selector->select(be.selector_block_env, &be.cands, &be.live);
}
- DB((be.dbg, LEVEL_2, "\tpicked node %+F\n", irn));
+ DB((dbg, LEVEL_2, "\tpicked node %+F\n", irn));
/* Add the node to the schedule. */
add_to_sched(&be, irn);
make_users_ready(&be, irn);
/* remove the scheduled node from the ready list. */
- if (nodeset_find(be.cands, irn))
- nodeset_remove(be.cands, irn);
+ ir_nodeset_remove(&be.cands, irn);
}
if (selector->finish_block)
selector->finish_block(be.selector_block_env);
- del_nodeset(be.cands);
- del_nodeset(be.live);
+ ir_nodeset_destroy(&be.cands);
+ ir_nodeset_destroy(&be.live);
}
/* List schedule a graph. */
memcpy(&sel, trivial_selector, sizeof(sel));
}
- /* Assure, that the out edges are computed */
- edges_assure(irg);
+#if 1
+ /* Matze: This is very slow, we should avoid it to improve backend speed,
+ * we just have to make sure that we have no dangling out-edges at this
+ * point...
+ */
+
+ /* Assure, that we have no dangling out-edges to deleted stuff */
+ edges_deactivate(birg->irg);
+ edges_activate(birg->irg);
+#endif
switch (list_sched_options.prep) {
case BE_SCHED_PREP_MRIS:
DEL_ARR_F(env.sched_info);
}
-#ifdef WITH_LIBCORE
+/* List schedule a block. */
+void list_sched_single_block(const be_irg_t *birg, ir_node *block, be_options_t *be_opts)
+{
+ const arch_env_t *arch_env = birg->main_env->arch_env;
+ ir_graph *irg = birg->irg;
+
+ int num_nodes;
+ sched_env_t env;
+ list_sched_selector_t sel;
+
+ /* Select a scheduler based on backend options */
+ switch (list_sched_options.select) {
+ case BE_SCHED_SELECT_TRIVIAL:
+ memcpy(&sel, trivial_selector, sizeof(sel));
+ break;
+ case BE_SCHED_SELECT_RANDOM:
+ memcpy(&sel, random_selector, sizeof(sel));
+ break;
+ case BE_SCHED_SELECT_REGPRESS:
+ memcpy(&sel, reg_pressure_selector, sizeof(sel));
+ break;
+ case BE_SCHED_SELECT_MUCHNIK:
+ memcpy(&sel, muchnik_selector, sizeof(sel));
+ break;
+ case BE_SCHED_SELECT_HEUR:
+ memcpy(&sel, heuristic_selector, sizeof(sel));
+ break;
+ case BE_SCHED_SELECT_HMUCHNIK:
+ default:
+ memcpy(&sel, trivial_selector, sizeof(sel));
+ }
+
+ /* Assure, that the out edges are computed */
+ edges_deactivate(birg->irg);
+ edges_activate(birg->irg);
+
+ num_nodes = get_irg_last_idx(irg);
+
+ /* initialize environment for list scheduler */
+ memset(&env, 0, sizeof(env));
+ env.selector = arch_env->isa->impl->get_list_sched_selector(arch_env->isa, &sel);
+ env.arch_env = arch_env;
+ env.irg = irg;
+ 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, arch_env, irg);
+
+ /* Schedule block. */
+ list_sched_block(block, &env);
+
+ if (env.selector->finish_graph)
+ env.selector->finish_graph(env.selector_env);
+
+ DEL_ARR_F(env.sched_info);
+}
+
/**
* Register list scheduler options.
*/
-void list_sched_register_options(lc_opt_entry_t *grp) {
- static int run_once = 0;
- lc_opt_entry_t *sched_grp;
+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");
- if (! run_once) {
- run_once = 1;
- sched_grp = lc_opt_get_grp(grp, "sched");
+ lc_opt_add_table(sched_grp, list_sched_option_table);
- lc_opt_add_table(sched_grp, list_sched_option_table);
- rss_register_options(sched_grp);
- }
+ FIRM_DBG_REGISTER(dbg, "firm.be.sched");
}
-#endif /* WITH_LIBCORE */
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_listsched);
projects / libfirm / blobdiff