X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyilp.c;h=3a6e4ed5f9ba8a9a50fc07e2319fcc72698c47ed;hb=2e291eab8268af551488b1f4fb4d9ca61b625e33;hp=b219b05ada27b05e40a0186dde516132481c2b1a;hpb=67b9a2ff3da2342b66b7124842ccd098df6fdbae;p=libfirm diff --git a/ir/be/becopyilp.c b/ir/be/becopyilp.c index b219b05ad..3a6e4ed5f 100644 --- a/ir/be/becopyilp.c +++ b/ir/be/becopyilp.c @@ -1,19 +1,85 @@ -/** - * Author: Daniel Grund - * Date: 28.02.2006 - * Copyright: (c) Universitaet Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. +/* + * Copyright (C) 1995-2008 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. * - * Common stuff used by all ILP fomulations. + * 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 Common stuff used by all ILP formulations. + * @author Daniel Grund + * @date 28.02.2006 + * @version $Id$ + */ #ifdef HAVE_CONFIG_H #include "config.h" #endif /* HAVE_CONFIG_H */ +#include "irtools.h" +#include "irprintf.h" + +#include "bestatevent.h" +#include "beirg_t.h" +#include "bemodule.h" +#include "error.h" + +#include "lc_opts.h" +#include "lc_opts_enum.h" + #ifdef WITH_ILP +#define DUMP_ILP 1 +#define DUMP_SOL 2 + +static int time_limit = 60; +static int solve_net = 1; +static int solve_log = 0; +static unsigned dump_flags = 0; + +static const lc_opt_enum_mask_items_t dump_items[] = { + { "ilp", DUMP_ILP }, + { "sol", DUMP_SOL }, + { NULL, 0 } +}; + +static lc_opt_enum_mask_var_t dump_var = { + &dump_flags, dump_items +}; + +static const lc_opt_table_entry_t options[] = { + LC_OPT_ENT_INT ("limit", "time limit for solving in seconds (0 for unlimited)", &time_limit), + LC_OPT_ENT_BOOL ("net", "solve over the net", &solve_net), + LC_OPT_ENT_BOOL ("log", "show ilp solving log", &solve_log), + LC_OPT_ENT_ENUM_MASK("dump", "dump flags", &dump_var), + LC_OPT_LAST +}; + +void be_init_copyilp(void) +{ + lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be"); + lc_opt_entry_t *ra_grp = lc_opt_get_grp(be_grp, "ra"); + lc_opt_entry_t *chordal_grp = lc_opt_get_grp(ra_grp, "chordal"); + lc_opt_entry_t *co_grp = lc_opt_get_grp(chordal_grp, "co"); + lc_opt_entry_t *ilp_grp = lc_opt_get_grp(co_grp, "ilp"); + + lc_opt_add_table(ilp_grp, options); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyilp); + #include "becopyilp_t.h" #include "beifg_t.h" @@ -29,7 +95,7 @@ size_red_t *new_size_red(copy_opt_t *co) { - size_red_t *res = malloc(sizeof(*res)); + size_red_t *res = XMALLOC(size_red_t); res->co = co; res->all_removed = pset_new_ptr_default(); @@ -68,16 +134,16 @@ static INLINE int sr_is_simplicial(size_red_t *sr, const ir_node *ifn) { void sr_remove(size_red_t *sr) { ir_node *irn; int redo = 1; - int n_nodes = 0; const be_ifg_t *ifg = sr->co->cenv->ifg; - void *iter = be_ifg_neighbours_iter_alloca(ifg); + void *iter = be_ifg_nodes_iter_alloca(ifg); while (redo) { - arch_register_req_t req; redo = 0; be_ifg_foreach_node(ifg, iter, irn) { - if (!sr_is_removed(sr, irn) && !co_is_optimizable(sr->co->aenv, irn, &req) && !co_is_optimizable_arg(sr->co, irn)) { - if (sr_is_simplicial(sr, irn)) { + const arch_register_req_t *req = arch_get_register_req(irn, -1); + + if (!arch_register_req_is(req, limited) && !sr_is_removed(sr, irn) && !co_gs_is_optimizable(sr->co, irn)) { + if (sr_is_simplicial(sr, irn)) { coloring_suffix_t *cs = obstack_alloc(&sr->ob, sizeof(*cs)); cs->irn = irn; @@ -87,7 +153,7 @@ void sr_remove(size_red_t *sr) { pset_insert_ptr(sr->all_removed, irn); redo = 1; - } + } } } } @@ -110,7 +176,7 @@ void sr_reinsert(size_red_t *sr) { be_ifg_foreach_neighbour(ifg, iter, irn, other) { if (!sr_is_removed(sr, other)) /* only inspect nodes which are in graph right now */ - bitset_set(used_cols, get_irn_col(sr->co, other)); + bitset_set(used_cols, get_irn_col(other)); } /* now all bits not set are possible colors */ @@ -137,32 +203,59 @@ void free_size_red(size_red_t *sr) { *****************************************************************************/ -ilp_env_t *new_ilp_env(copy_opt_t *co, firm_dbg_module_t *dbg, ilp_callback build, ilp_callback apply, void *env) { - ilp_env_t *res = malloc(sizeof(*res)); - assert(res); +#include - res->co = co; - res->dbg = dbg; - res->build = build; - res->apply = apply; - res->env = env; - res->sr = new_size_red(co); +ilp_env_t *new_ilp_env(copy_opt_t *co, ilp_callback build, ilp_callback apply, void *env) { + ilp_env_t *res = XMALLOC(ilp_env_t); + + res->co = co; + res->build = build; + res->apply = apply; + res->env = env; + res->sr = new_size_red(co); return res; } -lpp_sol_state_t ilp_go(ilp_env_t *ienv, double time_limit) { +lpp_sol_state_t ilp_go(ilp_env_t *ienv) { + be_main_env_t *main_env = ienv->co->cenv->birg->main_env; + sr_remove(ienv->sr); ienv->build(ienv); - lpp_set_time_limit(ienv->lp, time_limit); + if(solve_log) + lpp_set_log(ienv->lp, stdout); + + if(solve_net) + lpp_solve_net(ienv->lp, main_env->options->ilp_server, main_env->options->ilp_solver); + else { #ifdef LPP_SOLVE_NET - lpp_solve_net(ienv->lp, LPP_HOST, LPP_SOLVER); + fprintf(stderr, "can only solve ilp over the net\n"); #else - lpp_solve_cplex(ienv->lp); + lpp_solve_cplex(ienv->lp); #endif + } + + be_stat_ev_dbl("co_ilp_objval", ienv->lp->objval); + be_stat_ev_dbl("co_ilp_best_bound", ienv->lp->best_bound); + be_stat_ev ("co_ilp_iter", ienv->lp->iterations); + be_stat_ev_dbl("co_ilp_sol_time", ienv->lp->sol_time); + + if(dump_flags & DUMP_ILP) { + char buf[128]; + FILE *f; + + ir_snprintf(buf, sizeof(buf), "%F_%s-co.ilp", ienv->co->cenv->irg, + ienv->co->cenv->cls->name); + f = fopen(buf, "wt"); + if(f == NULL) { + panic("Couldn't open '%s' for writing", buf); + } + lpp_dump_plain(ienv->lp, f); + fclose(f); + } ienv->apply(ienv); @@ -179,7 +272,7 @@ void free_ilp_env(ilp_env_t *ienv) { #else /* WITH_ILP */ -static void only_that_you_can_compile_without_WITH_ILP_defined(void) { +static INLINE void only_that_you_can_compile_without_WITH_ILP_defined(void) { } #endif /* WITH_ILP */