X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbelistsched.c;h=dfaaad37b04ed444bed66d3045a8f8a596418a31;hb=07dda083afb68025db61c8278f430e0044e83977;hp=3db352a8e4bdcd78097f758a2723763238f25b8e;hpb=22e1dae4b74199ec476e3efb1b48d9f07b721aac;p=libfirm

diff --git a/ir/be/belistsched.c b/ir/be/belistsched.c
index 3db352a8e..dfaaad37b 100644
--- a/ir/be/belistsched.c
+++ b/ir/be/belistsched.c
@@ -1,9 +1,11 @@
 /**
  * Scheduling algorithms.
  * Just a simple list scheduling algorithm is here.
- * @date 20.10.2004
+ * @date   20.10.2004
  * @author Sebastian Hack
+ * @cvs-id $Id$
  */
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -11,8 +13,11 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
+#include <limits.h>
+
+#include "benode_t.h"
+#include "be_t.h"
 
-#include "fourcc.h"
 #include "obst.h"
 #include "list.h"
 #include "iterator.h"
@@ -23,168 +28,120 @@
 #include "irmode_t.h"
 #include "irdump.h"
 #include "irprintf_t.h"
+#include "array.h"
 #include "debug.h"
+#include "irtools.h"
 
 #include "besched_t.h"
 #include "beutil.h"
 #include "belive_t.h"
 #include "belistsched.h"
+#include "beschedmris.h"
+#include "bearch.h"
+#include "bestat.h"
+
+/**
+ * All scheduling info needed per node.
+ */
+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 {
-    const ir_graph *irg;                        /**< The graph to schedule. */
-    const list_sched_selector_t *selector;		  /**< The node selector. */
-    void *selector_env;                         /**< A pointer to give to the selector. */
+	sched_irn_t *sched_info;                    /**< scheduling info per node */
+	const list_sched_selector_t *selector;      /**< The node selector. */
+	const arch_env_t *arch_env;                 /**< The architecture environment. */
+	const ir_graph *irg;                        /**< The graph to schedule. */
+	void *selector_env;                         /**< A pointer to give to the selector. */
 } sched_env_t;
 
-#if 0
-/*
- * Ugly global variable for the compare function
- * since qsort(3) does not pass an extra pointer.
+/**
+ * Environment for a block scheduler.
  */
-static ir_node *curr_bl = NULL;
-
-static int cmp_usage(const void *a, const void *b)
-{
-	struct trivial_sched_env *env;
-	const ir_node *p = a;
-	const ir_node *q = b;
-	int res = 0;
-
-	res = is_live_end(env->curr_bl, a) - is_live_end(env->curr_bl, b);
-
-	/*
-	 * One of them is live at the end of the block.
-	 * Then, that one shall be scheduled at after the other
-	 */
-	if(res != 0)
-		return res;
-
-
-	return res;
-}
-#endif
-
-static ir_node *trivial_select(void *env, void *block_env,
-		const struct list_head *sched_head,
-		int curr_time, pset *ready_set)
-{
-#if 0
-	int i, n = pset_count(ready_set);
-	ir_node *irn;
-	ir_node **ready = alloca(n * sizeof(ready[0]));
-
-	for(irn = pset_first(ready_set); irn; irn = pset_next(ready_set))
-		ready[i++] = irn;
-#endif
-
-
-	ir_node *res = pset_first(ready_set);
-	pset_break(ready_set);
-	return res;
-}
-
-static const list_sched_selector_t trivial_selector_struct = {
-	NULL,
-	NULL,
-	trivial_select,
-	NULL,
-	NULL
-};
-
-const list_sched_selector_t *trivial_selector = &trivial_selector_struct;
-
-static void list_sched_block(ir_node *block, void *env_ptr);
+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_node *block;                             /**< the current block */
+	sched_env_t *sched_env;                     /**< the scheduler environment */
+	nodeset *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;
 
-void list_sched(ir_graph *irg, const list_sched_selector_t *selector)
+/**
+ * Returns non-zero if the node is already scheduled
+ */
+static INLINE int is_already_scheduled(block_sched_env_t *env, ir_node *n)
 {
-    sched_env_t env;
-
-    memset(&env, 0, sizeof(env));
-    env.selector = selector;
-    env.selector_env = selector->init_graph ? selector->init_graph(irg) : NULL;
-    env.irg = irg;
-
-		/* Assure, that the out edges are computed */
-		edges_assure(irg);
-
-    /* Schedule each single block. */
-    irg_block_walk_graph(irg, list_sched_block, NULL, &env);
+	int idx = get_irn_idx(n);
 
-		if(selector->finish_graph)
-			selector->finish_graph(env.selector_env, irg);
+	assert(idx < ARR_LEN(env->sched_info));
+	return env->sched_info[idx].already_sched;
 }
 
-
 /**
- * Environment for a block scheduler.
+ * Mark a node as already scheduled
  */
-typedef struct _block_sched_env_t {
-    int curr_time;
-    pset *ready_set;
-    pset *already_scheduled;
-    ir_node *block;
-		firm_dbg_module_t *dbg;
-} block_sched_env_t;
-
-
+static INLINE void mark_already_scheduled(block_sched_env_t *env, ir_node *n)
+{
+	int idx = get_irn_idx(n);
 
+	assert(idx < ARR_LEN(env->sched_info));
+	env->sched_info[idx].already_sched = 1;
+}
 
 /**
  * Try to put a node in the ready set.
- * @param env The block scheduler environment.
- * @param irn The node to make ready.
+ * @param env   The block scheduler environment.
+ * @param pred  The previous scheduled node.
+ * @param irn   The node to make ready.
  * @return 1, if the node could be made ready, 0 else.
  */
-static INLINE int make_ready(block_sched_env_t *env, ir_node *irn)
+static INLINE int make_ready(block_sched_env_t *env, ir_node *pred, ir_node *irn)
 {
-    int i, n;
+	int i, n;
 
     /* Blocks cannot be scheduled. */
-    if(is_Block(irn))
+    if (is_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))
+    if (env->block != get_nodes_block(irn))
         return 0;
 
-    for(i = 0, n = get_irn_arity(irn); i < n; ++i) {
-        ir_node *op = get_irn_n(irn, i);
+	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(!pset_find_ptr(env->already_scheduled, op) && get_nodes_block(op) == env->block)
+        if (! is_already_scheduled(env, op) && get_nodes_block(op) == env->block)
             return 0;
     }
 
-    DBG((env->dbg, LEVEL_2, "\tmaking ready: %+F\n", irn));
-    pset_insert_ptr(env->ready_set, irn);
+	nodeset_insert(env->cands, irn);
 
-    return 1;
-}
+	/* Notify selector about the ready node. */
+	if (env->selector->node_ready)
+		env->selector->node_ready(env->selector_block_env, irn, pred);
 
-/**
- * Check, if a node is ready in a block schedule.
- * @param env The block schedule environment.
- * @param irn The node to check for.
- * @return 1 if the node was ready, 0 if not.
- */
-#define is_ready(env,irn) \
-  (pset_find_ptr((env)->ready_set, irn) != NULL)
+    DB((env->dbg, LEVEL_2, "\tmaking ready: %+F\n", irn));
 
-/**
- * Check, if a node has already been schedules.
- * @param env The block schedule environment.
- * @param irn The node to check for.
- * @return 1 if the node was already scheduled, 0 if not.
- */
-#define is_scheduled(env,irn) \
-  (pset_find_ptr((env)->already_scheduled, irn) != NULL)
+    return 1;
+}
 
 /**
  * Try, to make all users of a node ready.
@@ -195,57 +152,164 @@ static INLINE int make_ready(block_sched_env_t *env, ir_node *irn)
  */
 static INLINE void make_users_ready(block_sched_env_t *env, ir_node *irn)
 {
-	int i, n;
 	const ir_edge_t *edge;
 
 	foreach_out_edge(irn, edge) {
-		ir_node *user = edge->src;
-		if(!is_Phi(user))
-			make_ready(env, user);
+		ir_node *user = get_edge_src_irn(edge);
+		if (! is_Phi(user))
+			make_ready(env, irn, user);
 	}
+
+	foreach_out_edge_kind(irn, edge, EDGE_KIND_DEP) {
+		ir_node *user = get_edge_src_irn(edge);
+		if (! is_Phi(user))
+			make_ready(env, irn, user);
+	}
+}
+
+/**
+ * Returns the number of not yet schedules users.
+ */
+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));
+	return env->sched_info[idx].num_not_sched_user;
+}
+
+/**
+ * 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) {
+	int idx = get_irn_idx(n);
+
+	assert(idx < ARR_LEN(env->sched_info));
+	env->sched_info[idx].num_not_sched_user = num;
 }
 
 /**
- * Compare to nodes using pointer equality.
- * @param p1 Node one.
- * @param p2 Node two.
- * @return 0 if they are identical.
+ * Add @p num to the number of not yet schedules users and returns the result.
  */
-static int node_cmp_func(const void *p1, const void *p2)
+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));
+	env->sched_info[idx].num_not_sched_user += num;
+	return env->sched_info[idx].num_not_sched_user;
+}
+
+/**
+ * Returns the number of users of a node having mode datab.
+ */
+static int get_num_successors(ir_node *irn) {
+	int             sum = 0;
+	const ir_edge_t *edge;
+
+	if (get_irn_mode(irn) == mode_T) {
+		/* for mode_T nodes: count the users of all Projs */
+		foreach_out_edge(irn, edge) {
+			ir_node *proj = get_edge_src_irn(edge);
+			ir_mode *mode = get_irn_mode(proj);
+
+			if (mode == mode_T)
+				sum += get_num_successors(proj);
+			else if (mode_is_datab(mode))
+				sum += get_irn_n_edges(proj);
+		}
+	}
+	else {
+		/* do not count keep-alive edges */
+		foreach_out_edge(irn, edge) {
+			if (get_irn_opcode(get_edge_src_irn(edge)) != iro_End)
+				sum++;
+		}
+	}
+
+	return sum;
+}
+
+/**
+ * Adds irn to @p live, updates all inputs that this user is scheduled
+ * and counts all of it's non scheduled users.
+ */
+static void update_sched_liveness(block_sched_env_t *env, ir_node *irn) {
+	int i;
+
+	/* ignore Projs */
+	if (is_Proj(irn))
+		return;
+
+	for (i = get_irn_ins_or_deps(irn) - 1; i >= 0; --i) {
+		ir_node *in = get_irn_in_or_dep(irn, i);
+
+		/* if in is a proj: update predecessor */
+		while (is_Proj(in))
+			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 (add_irn_not_sched_user(env, in, -1) <= 0)
+				nodeset_remove(env->live, in);
+		}
+	}
+
+	/*
+		get_num_successors returns the number of all users. This includes
+		users in different blocks as well. As the each block is scheduled separately
+		the liveness info of those users will not be updated and so these
+		users will keep up the register pressure as it is desired.
+	*/
+	i = get_num_successors(irn);
+	if (i > 0) {
+		set_irn_not_sched_user(env, irn, i);
+		nodeset_insert(env->live, irn);
+	}
+}
+
+static INLINE int must_appear_in_schedule(const list_sched_selector_t *sel, void *block_env, const ir_node *irn)
 {
-    return p1 != p2;
+	int res = -1;
+
+	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));
 }
 
 /**
  * Append an instruction to a schedule.
- * @param env The block scheduleing environment.
+ * @param env The block scheduling environment.
  * @param irn The node to add to the schedule.
- * @return The given node.
+ * @return    The given node.
  */
 static ir_node *add_to_sched(block_sched_env_t *env, ir_node *irn)
 {
     /* If the node consumes/produces data, it is appended to the schedule
      * list, otherwise, it is not put into the list */
-    if(to_appear_in_schedule(irn)) {
+    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));
     }
 
+	/* notify the selector about the finally selected node. */
+	if (env->selector->node_selected)
+		env->selector->node_selected(env->selector_block_env, irn);
+
     /* Insert the node in the set of all already scheduled nodes. */
-    pset_insert_ptr(env->already_scheduled, irn);
+    mark_already_scheduled(env, irn);
 
     /* Remove the node from the ready set */
-    if(pset_find_ptr(env->ready_set, irn))
-        pset_remove_ptr(env->ready_set, irn);
+    if(nodeset_find(env->cands, irn))
+        nodeset_remove(env->cands, irn);
 
     return irn;
 }
 
-
 /**
  * Add the proj nodes of a tuple-mode irn to the schedule immediately
  * after the tuple-moded irn. By pinning the projs after the irn, no
@@ -255,28 +319,30 @@ static ir_node *add_to_sched(block_sched_env_t *env, ir_node *irn)
  * values.
  *
  * @param irn The tuple-moded irn.
- * @param list The schedule list to append all the projs.
- * @param time The time step to which the irn and all its projs are
- * related to.
- * @param obst The obstack the scheduling data structures shall be
- * created upon.
- * @param ready_set The ready set of the list scheduler.
- * @param already_scheduled A set containing all nodes already
- * scheduled.
  */
 static void add_tuple_projs(block_sched_env_t *env, ir_node *irn)
 {
-	int i, n;
 	const ir_edge_t *edge;
 
 	assert(get_irn_mode(irn) == mode_T && "Mode of node must be tuple");
 
+	if(is_Bad(irn))
+		return;
+
+
+	/* non-proj nodes can have dependency edges to tuple nodes. */
+	foreach_out_edge_kind(irn, edge, EDGE_KIND_DEP) {
+		ir_node *out = get_edge_src_irn(edge);
+		make_ready(env, irn, out);
+	}
+
+	/* schedule the normal projs */
 	foreach_out_edge(irn, edge) {
-		ir_node *out = edge->src;
+		ir_node *out = get_edge_src_irn(edge);
 
 		assert(is_Proj(out) && "successor of a modeT node must be a proj");
 
-		if(get_irn_mode(out) == mode_T)
+		if (get_irn_mode(out) == mode_T)
 			add_tuple_projs(env, out);
 		else {
 			add_to_sched(env, out);
@@ -294,106 +360,186 @@ static void add_tuple_projs(block_sched_env_t *env, ir_node *irn)
  * Also the outs must have been computed.
  *
  * @param block The block node.
- * @param env Schedulting environment.
+ * @param env Scheduling environment.
  */
 static void list_sched_block(ir_node *block, void *env_ptr)
 {
-	void *block_env = NULL;
-	sched_env_t *env = env_ptr;
-	block_sched_env_t be;
+	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;
 	ir_node *irn;
-	int i, n, j, m;
-	int phi_seen = 0;
-	sched_info_t *info = get_irn_sched_info(block);
+	int j, m;
 
 	/* Initialize the block's list head that will hold the schedule. */
 	INIT_LIST_HEAD(&info->list);
 
 	/* Initialize the block scheduling environment */
-	be.dbg = firm_dbg_register("firm.be.sched");
-	be.block = block;
-	be.curr_time = 0;
-	be.ready_set = new_pset(node_cmp_func, get_irn_n_edges(block));
-	be.already_scheduled = new_pset(node_cmp_func, get_irn_n_edges(block));
-
-	firm_dbg_set_mask(be.dbg, 0);
-
-	if(selector->init_block)
-		block_env = selector->init_block(env->selector_env, block);
+	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));
+	be.selector          = selector;
+	be.sched_env         = env;
+	FIRM_DBG_REGISTER(be.dbg, "firm.be.sched");
 
 	DBG((be.dbg, LEVEL_1, "scheduling %+F\n", block));
 
+	if (selector->init_block)
+		be.selector_block_env = selector->init_block(env->selector_env, block);
+
 	/* Then one can add all nodes are ready to the set. */
 	foreach_out_edge(block, edge) {
 		ir_node *irn = get_edge_src_irn(edge);
 
 		/* Skip the end node because of keepalive edges. */
-		if(get_irn_opcode(irn) == iro_End)
+		if (get_irn_opcode(irn) == iro_End)
 			continue;
 
-		/* Phi functions are scheduled immediately, since they only transfer
-		 * data flow from the predecessors to this block. */
-		if(is_Phi(irn)) {
+		if (is_Phi(irn)) {
+			/*
+				Phi functions are scheduled immediately, since they	only
+				transfer data flow from the predecessors to this block.
+			*/
 			add_to_sched(&be, irn);
 			make_users_ready(&be, irn);
-			phi_seen = 1;
 		}
-
-		/* Other nodes must have all operands in other blocks to be made
-		 * ready */
+		else if (irn == start_node) {
+			/* The start block will be scheduled as the first node */
+			add_to_sched(&be, irn);
+			add_tuple_projs(&be, irn);
+		}
 		else {
+			/* Other nodes must have all operands in other blocks to be made
+			* ready */
 			int ready = 1;
 
 			/* Check, if the operands of a node are not local to this block */
-			for(j = 0, m = get_irn_arity(irn); j < m; ++j) {
-				ir_node *operand = get_irn_n(irn, j);
+			for (j = 0, m = get_irn_ins_or_deps(irn); j < m; ++j) {
+				ir_node *operand = get_irn_in_or_dep(irn, j);
 
-				if(get_nodes_block(operand) == block) {
+				if (get_nodes_block(operand) == block) {
 					ready = 0;
 					break;
 				}
+				else {
+					/* live in values increase register pressure */
+					update_sched_liveness(&be, operand);
+				}
 			}
 
 			/* Make the node ready, if all operands live in a foreign block */
-			if(ready) {
+			if (ready) {
 				DBG((be.dbg, LEVEL_2, "\timmediately ready: %+F\n", irn));
-				make_ready(&be, irn);
+				make_ready(&be, NULL, irn);
 			}
 		}
 	}
 
-	/* Increase the time, if some phi functions have been scheduled */
-	be.curr_time += phi_seen;
+	/* Iterate over all remaining nodes */
+	while (nodeset_count(be.cands) > 0) {
+		/* collect statistics about amount of ready nodes */
+		be_do_stat_sched_ready(block, be.cands);
 
-	while(pset_count(be.ready_set) > 0) {
-		// DBG((be.dbg, LEVEL_2, "\tready set: %*n\n", pset_iterator, be.ready_set));
+		/* Keeps must be scheduled immediatly */
+		foreach_nodeset(be.cands, irn) {
+			if (be_is_Keep(irn) || be_is_CopyKeep(irn)) {
+				nodeset_break(be.cands);
+				break;
+			}
+		}
 
-		/* select a node to be scheduled and check if it was ready */
-		irn = selector->select(env->selector_env, block_env, &info->list, be.curr_time, be.ready_set);
+		if (! irn) {
+			/* Keeps must be immediately scheduled */
+			irn = be.selector->select(be.selector_block_env, be.cands, be.live);
+		}
 
-		DBG((be.dbg, LEVEL_3, "\tpicked node %+F\n", irn));
+		DB((be.dbg, LEVEL_2, "\tpicked node %+F\n", irn));
 
 		/* Add the node to the schedule. */
 		add_to_sched(&be, irn);
 
-		if(get_irn_mode(irn) == mode_T)
+		if (get_irn_mode(irn) == mode_T)
 			add_tuple_projs(&be, irn);
 		else
 			make_users_ready(&be, irn);
 
-		/* Increase the time step. */
-		be.curr_time += 1;
-
 		/* remove the scheduled node from the ready list. */
-		if(pset_find_ptr(be.ready_set, irn))
-			pset_remove_ptr(be.ready_set, irn);
+		if (nodeset_find(be.cands, irn))
+			nodeset_remove(be.cands, irn);
+	}
+
+	if (selector->finish_block)
+		selector->finish_block(be.selector_block_env);
+
+	del_nodeset(be.cands);
+	del_nodeset(be.live);
+}
+
+/* List schedule a graph. */
+void list_sched(const be_irg_t *birg, 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;
+	mris_env_t *mris = NULL;
+	list_sched_selector_t sel;
+
+	/* Select a scheduler based on backend options */
+	switch (be_opts->sched_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));
 	}
 
-	if(selector->finish_block)
-		selector->finish_block(env->selector_env, block_env, block);
+	/* Assure, that the out edges are computed */
+	edges_assure(irg);
+
+	if (be_opts->mris)
+		mris = be_sched_mris_preprocess(birg);
+
+	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 each single block. */
+	irg_block_walk_graph(irg, list_sched_block, NULL, &env);
+
+	if (env.selector->finish_graph)
+		env.selector->finish_graph(env.selector_env);
+
+	if (be_opts->mris)
+		be_sched_mris_free(mris);
 
-	del_pset(be.ready_set);
-	del_pset(be.already_scheduled);
+	DEL_ARR_F(env.sched_info);
 }