X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbelistsched.c;h=300f9204945f1bda9dca244116a91ba7e63e95d2;hb=dfc341ac6f54b4b0922d605e28333be76f487c68;hp=57f66992f60b040684250324dccfbce45da052ee;hpb=3fb0ea8b22c5cc0665f8a74e27857cd304fac912;p=libfirm

diff --git a/ir/be/belistsched.c b/ir/be/belistsched.c
index 57f66992f..300f92049 100644
--- a/ir/be/belistsched.c
+++ b/ir/be/belistsched.c
@@ -1,11 +1,29 @@
-/**
- * Scheduling algorithms.
- * Just a simple list scheduling algorithm is here.
- * @date   20.10.2004
- * @author Sebastian Hack
- * @cvs-id $Id$
+/*
+ * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
  */
 
+/**
+ * @file
+ * @brief       Primitive list scheduling with different node selectors.
+ * @author      Sebastian Hack
+ * @date        20.10.2004
+ * @version     $Id$
+ */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -39,12 +57,15 @@
 #include "belistsched.h"
 #include "beschedmris.h"
 #include "beschedrss.h"
-#include "bearch.h"
+#include "bearch_t.h"
 #include "bestat.h"
+#include "beirg_t.h"
 
 #include <libcore/lc_opts.h>
 #include <libcore/lc_opts_enum.h>
 
+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 {
@@ -129,13 +150,12 @@ typedef struct _sched_env_t {
  */
 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;
 
 /**
@@ -197,13 +217,13 @@ static INLINE int make_ready(block_sched_env_t *env, ir_node *pred, ir_node *irn
 			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;
 }
@@ -312,9 +332,9 @@ static void update_sched_liveness(block_sched_env_t *env, ir_node *irn) {
 			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);
 		}
 	}
 
@@ -327,7 +347,7 @@ static void update_sched_liveness(block_sched_env_t *env, ir_node *irn) {
 	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);
 	}
 }
 
@@ -358,7 +378,7 @@ static ir_node *add_to_sched(block_sched_env_t *env, ir_node *irn)
 		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. */
@@ -369,8 +389,7 @@ static ir_node *add_to_sched(block_sched_env_t *env, ir_node *irn)
     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;
 }
@@ -444,13 +463,12 @@ static void list_sched_block(ir_node *block, void *env_ptr)
 	/* 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);
@@ -500,31 +518,31 @@ static void list_sched_block(ir_node *block, void *env_ptr)
 
 			/* 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) {
+		foreach_ir_nodeset(&be.cands, irn, iter) {
 			if (be_is_Keep(irn) || be_is_CopyKeep(irn) || is_Sync(irn)) {
-				nodeset_break(be.cands);
 				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);
@@ -535,15 +553,14 @@ static void list_sched_block(ir_node *block, void *env_ptr)
 			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. */
@@ -579,9 +596,16 @@ void list_sched(const be_irg_t *birg, be_options_t *be_opts)
 			memcpy(&sel, trivial_selector, sizeof(sel));
 	}
 
-	/* Assure, that the out edges are computed */
+#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:
@@ -687,6 +711,8 @@ void be_init_listsched(void) {
 	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);