+/*
+ * 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.
+ */
+
/**
- * Author: Daniel Grund
- * Date: 12.04.2005
- * Copyright: (c) Universitaet Karlsruhe
- * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ * @file
+ * @brief Copy minimization driver.
+ * @author Daniel Grund
+ * @date 12.04.2005
+ * @version $Id$
+ *
+ * Main file for the optimization reducing the copies needed for:
+ * - Phi coalescing
+ * - Register-constrained nodes
+ * - Two-address code instructions
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#include "bestatevent.h"
#include "beirg_t.h"
#include "error.h"
+#include "bera.h"
#include <libcore/lc_timing.h>
#include <libcore/lc_opts.h>
#define COST_FUNC_LOOP 2
#define COST_FUNC_ALL_ONE 3
-static unsigned dump_flags = 0;
-static unsigned style_flags = 0;
-static unsigned do_stats = 0;
+static unsigned dump_flags = 0;
+static unsigned style_flags = 0;
+static unsigned do_stats = 0;
static cost_fct_t cost_func = co_get_costs_exec_freq;
-static unsigned algo = CO_ALGO_HEUR2;
-static int improve = 1;
+static unsigned algo = CO_ALGO_HEUR;
+static int improve = 1;
static const lc_opt_enum_mask_items_t dump_items[] = {
{ "before", DUMP_BEFORE },
#ifdef WITH_JVM
{ "heur3", CO_ALGO_HEUR3 },
#endif /* WITH_JVM */
+ { "heur4", CO_ALGO_HEUR4 },
#ifdef WITH_ILP
{ "ilp", CO_ALGO_ILP },
#endif /* WITH_ILP */
static int nodes_interfere(const be_chordal_env_t *env, const ir_node *a, const ir_node *b)
{
- if(env->ifg)
+ if (env->ifg)
return be_ifg_connected(env->ifg, a, b);
else
return values_interfere(env->birg->lv, a, b);
/* Else insert the argument of the phi to the members of this ou */
DBG((dbg, LEVEL_1, "\t Member: %+F\n", arg));
- /* Check if arg has occurred at a prior position in the arg/list */
- arg_pos = 0;
- for (o=0; o<unit->node_count; ++o)
- if (unit->nodes[o] == arg) {
- arg_pos = o;
- break;
+ if (! arch_irn_is(co->aenv, arg, ignore)) {
+ /* Check if arg has occurred at a prior position in the arg/list */
+ arg_pos = 0;
+ for (o=1; o<unit->node_count; ++o) {
+ if (unit->nodes[o] == arg) {
+ arg_pos = o;
+ break;
+ }
}
- if (!arg_pos) { /* a new argument */
- /* insert node, set costs */
- unit->nodes[unit->node_count] = arg;
- unit->costs[unit->node_count] = co->get_costs(co, irn, arg, i);
- unit->node_count++;
- } else { /* arg has occured before in same phi */
- /* increase costs for existing arg */
- unit->costs[arg_pos] += co->get_costs(co, irn, arg, i);
+ if (!arg_pos) { /* a new argument */
+ /* insert node, set costs */
+ unit->nodes[unit->node_count] = arg;
+ unit->costs[unit->node_count] = co->get_costs(co, irn, arg, i);
+ unit->node_count++;
+ } else { /* arg has occured before in same phi */
+ /* increase costs for existing arg */
+ unit->costs[arg_pos] += co->get_costs(co, irn, arg, i);
+ }
}
}
unit->nodes = xrealloc(unit->nodes, unit->node_count * sizeof(*unit->nodes));
be_liveness_recompute(lv);
obstack_init(&env.obst);
- phase_init(&env.ph, "appel_clique_dumper", co->irg, PHASE_DEFAULT_GROWTH, appel_clique_walker_irn_init);
+ phase_init(&env.ph, "appel_clique_dumper", co->irg, PHASE_DEFAULT_GROWTH, appel_clique_walker_irn_init, NULL);
env.curr_nr = co->cls->n_regs;
env.co = co;
env.f = f;
*/
typedef struct {
- co_algo_t *algo;
+ co_algo_t *algo;
const char *name;
- int can_improve_existing;
+ int can_improve_existing;
} co_algo_info_t;
static co_algo_info_t algos[] = {
- { void_algo, "none", 0 },
- { co_solve_heuristic, "heur1", 0 },
- { co_solve_heuristic_new, "heur2", 0 },
- { co_solve_heuristic_java, "heur3", 0 },
+ { void_algo, "none", 0 },
+ { co_solve_heuristic, "heur1", 0 },
+ { co_solve_heuristic_new, "heur2", 0 },
+ { co_solve_heuristic_java, "heur3", 0 },
+ { co_solve_heuristic_mst, "heur4", 0 },
#ifdef WITH_ILP
- { co_solve_ilp2, "ilp", 1 },
+ { co_solve_ilp2, "ilp", 1 },
#endif
- { NULL, "", 0 }
+ { NULL, "", 0 }
};
/*
void co_driver(be_chordal_env_t *cenv)
{
- lc_timer_t *timer = lc_timer_register("firm.be.copyopt", "runtime");
+ lc_timer_t *timer = lc_timer_register("firm.be.copyopt", "runtime");
co_complete_stats_t before, after;
- copy_opt_t *co;
- co_algo_t *algo_func;
- int was_optimal = 0;
+ copy_opt_t *co;
+ co_algo_t *algo_func;
+ int was_optimal = 0;
- if(algo < 0 || algo >= CO_ALGO_LAST)
+ if (algo < 0 || algo >= CO_ALGO_LAST)
return;
co = new_copy_opt(cenv, cost_func);
be_stat_ev_ull("co_init_unsat", before.unsatisfied_edges);
/* Dump the interference graph in Appel's format. */
- if(dump_flags & DUMP_APPEL) {
+ if (dump_flags & DUMP_APPEL) {
FILE *f = my_open(cenv, "", ".apl");
co_dump_appel_graph(co, f);
fclose(f);
}
- if(dump_flags & DUMP_BEFORE) {
+ if (dump_flags & DUMP_BEFORE) {
FILE *f = my_open(cenv, "", "-before.dot");
co_dump_ifg_dot(co, f, style_flags);
fclose(f);
}
/* if the algo can improve results, provide an initial solution with heur3 */
- if(improve && algos[algo].can_improve_existing) {
+ if (improve && algos[algo].can_improve_existing) {
co_complete_stats_t stats;
- /* produce a heuristical solution */
+ /* produce a heuristic solution */
+#ifdef WITH_JVM
co_solve_heuristic_java(co);
+#else
+ co_solve_heuristic(co);
+#endif /* WITH_JVM */
/* do the stats and provide the current costs */
co_complete_stats(co, &stats);
#ifdef WITH_JVM
/* start the JVM here so that it does not tamper the timing. */
- if(algo == CO_ALGO_HEUR3)
+ if (algo == CO_ALGO_HEUR3)
be_java_coal_start_jvm();
-#endif
+#endif /* WITH_JVM */
algo_func = algos[algo].algo;
+ /* perform actual copy minimization */
lc_timer_reset_and_start(timer);
-
was_optimal = algo_func(co);
-
lc_timer_stop(timer);
- be_stat_ev("co_time", lc_timer_elapsed_msec(timer));
+ be_stat_ev("co_time", lc_timer_elapsed_msec(timer));
be_stat_ev_ull("co_optimal", was_optimal);
- if(dump_flags & DUMP_AFTER) {
+ if (dump_flags & DUMP_AFTER) {
FILE *f = my_open(cenv, "", "-after.dot");
co_dump_ifg_dot(co, f, style_flags);
fclose(f);
co_complete_stats(co, &after);
- if(do_stats) {
+ if (do_stats) {
ulong64 optimizable_costs = after.max_costs - after.inevit_costs;
ulong64 evitable = after.costs - after.inevit_costs;