X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeprofile.c;h=307480067266382a8b1f9a47ea0932cb4d0edf56;hb=67b6304bf1b2df3cefa9f39151ed7436e64c48dd;hp=829c766c079a9c67b57a8e51db92b95f59b66164;hpb=c6e2a2ca59b65e4939d0af1088cca3f9e1a0bab1;p=libfirm diff --git a/ir/be/beprofile.c b/ir/be/beprofile.c index 829c766c0..307480067 100644 --- a/ir/be/beprofile.c +++ b/ir/be/beprofile.c @@ -1,13 +1,28 @@ -/** vim: set sw=4 ts=4: - * @file beprofile.c - * @date 2006-04-06 - * @author Adam M. Szalkowski - * @cvs-id $Id$ +/* + * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. * - * Code instrumentation and execution count profiling + * This file is part of libFirm. * - * Copyright (C) 2006 Universitaet Karlsruhe - * Released under the GPL + * 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 Code instrumentation and execution count profiling. + * @author Adam M. Szalkowski + * @date 06.04.2006 + * @version $Id$ */ #ifdef HAVE_CONFIG_H #include "config.h" @@ -22,7 +37,6 @@ #include "list.h" #include "pmap.h" -#include "entity.h" #include "irprintf.h" #include "irgwalk.h" #include "irdump_t.h" @@ -32,33 +46,38 @@ #include "iredges.h" #include "execfreq.h" #include "irvrfy.h" -#include "type.h" -#include "entity.h" +#include "typerep.h" #include "be_t.h" #include "belive_t.h" #include "besched_t.h" #include "beirgmod.h" -#include "bearch.h" +#include "bearch_t.h" #include "beabi.h" #include "benode_t.h" #include "beutil.h" #include "ircons.h" #include "irhooks.h" +#include "iredges.h" #include "bechordal_t.h" -#ifdef WITH_LIBCORE -#include -#include -#endif /* WITH_LIBCORE */ - #include "beprofile.h" +/** An entry in the id-to-location map */ +typedef struct loc_entry { + ir_entity *fname; /**< the entity holding the file name */ + unsigned int lineno; /**< line number */ +} loc_entry; + typedef struct _block_id_walker_data_t { - tarval **array; - unsigned int id; - ir_node *symconst; + tarval **array; /**< the entity the holds the block counts */ + unsigned int id; /**< current block id number */ + ir_node *symconst; /**< the SymConst representing array */ + pmap *fname_map; /**< set containing all found filenames */ + loc_entry *locs; /**< locations */ + ir_type *tp_char; /**< the character type */ + unsigned flags; /**< profile flags */ } block_id_walker_data_t; typedef struct _execcount_t { @@ -69,6 +88,7 @@ typedef struct _execcount_t { static int cmp_execcount(const void * a, const void * b, size_t size) { + (void) size; return ((execcount_t*)a)->block != ((execcount_t*)b)->block; } @@ -76,6 +96,7 @@ static void block_counter(ir_node * bb, void * data) { unsigned int *count = data; + (void) bb; *count = *count + 1; } @@ -103,7 +124,10 @@ instrument_block(ir_node * bb, ir_node * address, unsigned int id) ir_node *load, *store, *offset, *add, *projm, *proji, *unknown; ir_node *cnst; - if(bb == start_block || bb == get_irg_end_block(irg)) + /** + * We can't instrument the end block as there are no real instructions there + */ + if(bb == get_irg_end_block(irg)) return; unknown = new_r_Unknown(irg, mode_M); @@ -121,7 +145,6 @@ instrument_block(ir_node * bb, ir_node * address, unsigned int id) } typedef struct fix_env { - ir_node *start_block; ir_node *end_block; } fix_env; @@ -136,10 +159,12 @@ fix_ssa(ir_node * bb, void * data) int arity = get_Block_n_cfgpreds(bb); /* start and end block are not instrumented, skip! */ - if (bb == env->start_block || bb == env->end_block) + if (bb == env->end_block) return; - if (arity == 1) { + if (bb == get_irg_start_block(get_irn_irg(bb))) { + mem = new_NoMem(); + } else if (arity == 1) { mem = get_irn_link(get_Block_cfgpred_block(bb, 0)); } else { int n; @@ -163,20 +188,20 @@ fix_ssa(ir_node * bb, void * data) * void __firmprof_initializer(void) { __init_firmprof(ent_filename, bblock_id, bblock_counts, n_blocks); } */ static ir_graph * -gen_initializer_irg(entity * ent_filename, entity * bblock_id, entity * bblock_counts, int n_blocks) +gen_initializer_irg(ir_entity * ent_filename, ir_entity * bblock_id, ir_entity * bblock_counts, int n_blocks) { ir_node *start_block; ir_node *ins[4]; ident *name = new_id_from_str("__firmprof_initializer"); - entity *ent = new_entity(get_glob_type(), name, new_type_method(name, 0, 0)); + ir_entity *ent = new_entity(get_glob_type(), name, new_type_method(name, 0, 0)); ir_node *ret, *call, *symconst; symconst_symbol sym; ident *init_name = new_id_from_str("__init_firmprof"); ir_type *init_type = new_type_method(init_name, 4, 0); ir_type *uint, *uintptr, *string; - entity *init_ent; + ir_entity *init_ent; ir_graph *irg; ir_node *bb; ir_type *empty_frame_type; @@ -225,6 +250,59 @@ gen_initializer_irg(entity * ent_filename, entity * bblock_id, entity * bblock_c return irg; } +/** + * Create the location data for the given debug info. + */ +static void create_location_data(dbg_info *dbg, block_id_walker_data_t *wd) +{ + unsigned lineno; + const char *fname = be_retrieve_dbg_info(dbg, &lineno); + + if (fname) { + pmap_entry *entry = pmap_find(wd->fname_map, (void *)fname); + ir_entity *ent; + + if (! entry) { + static unsigned nr = 0; + ident *id; + char buf[128]; + ir_type *arr; + int i, len = strlen(fname) + 1; + tarval **tarval_string; + + snprintf(buf, sizeof(buf), "firm_name_arr.%d", nr); + arr = new_type_array(new_id_from_str(buf), 1, wd->tp_char); + set_array_bounds_int(arr, 0, 0, len); + + snprintf(buf, sizeof(buf), "__firm_name.%d", nr++); + id = new_id_from_str(buf); + ent = new_entity(get_glob_type(), id, arr); + set_entity_ld_ident(ent, id); + + pmap_insert(wd->fname_map, (void *)fname, ent); + + /* initialize file name string constant */ + tarval_string = alloca(sizeof(*tarval_string) * (len)); + for (i = 0; i < len; ++i) { + tarval_string[i] = new_tarval_from_long(fname[i], mode_Bs); + } + set_entity_variability(ent, variability_constant); + set_array_entity_values(ent, tarval_string, len); + } else { + ent = entry->value; + } + wd->locs[wd->id].fname = ent; + wd->locs[wd->id].lineno = lineno; + } else { + wd->locs[wd->id].fname = NULL; + wd->locs[wd->id].lineno = 0; + } +} + +/** + * Walker: assigns an ID to every block. + * Builds the string table + */ static void block_id_walker(ir_node * bb, void * data) { @@ -232,53 +310,119 @@ block_id_walker(ir_node * bb, void * data) wd->array[wd->id] = new_tarval_from_long(get_irn_node_nr(bb), mode_Iu); instrument_block(bb, wd->symconst, wd->id); + + if (wd->flags & profile_with_locations) { + dbg_info *dbg = get_irn_dbg_info(bb); + create_location_data(dbg, wd); + } ++wd->id; } +#define IDENT(x) new_id_from_chars(x, sizeof(x) - 1) + ir_graph * -be_profile_instrument(char * filename) +be_profile_instrument(const char *filename, unsigned flags) { - int n, i; - unsigned int n_blocks = 0; - entity *bblock_id, *bblock_counts, *ent_filename; - ir_type *array_type, *integer_type, *string_type, *character_type; - tarval **tarval_array, **tarval_string, *tv; - int filename_len = strlen(filename)+1; - ident *cur_ident; - + int n, i; + int n_blocks = 0; + ir_entity *bblock_id; + ir_entity *bblock_counts; + ir_entity *ent_filename; + ir_entity *ent_locations = NULL; + ir_entity *loc_lineno = NULL; + ir_entity *loc_name = NULL; + ir_entity *ent; + ir_type *array_type; + ir_type *uint_type; + ir_type *string_type; + ir_type *character_type; + ir_type *loc_type = NULL; + ir_type *charptr_type; + ir_type *gtp; + ir_node *start_block; + tarval **tarval_array; + tarval **tarval_string; + tarval *tv; + int filename_len = strlen(filename)+1; + ident *cur_ident; + int align_l, align_n, size; + ir_graph *rem; block_id_walker_data_t wd; symconst_symbol sym; - integer_type = new_type_primitive(new_id_from_str("__uint"), mode_Iu); - array_type = new_type_array(new_id_from_str("__block_info_array"), 1, integer_type); + /* count the number of block first */ + for (n = get_irp_n_irgs() - 1; n >= 0; --n) { + ir_graph *irg = get_irp_irg(n); + + n_blocks += count_blocks(irg); + } + + /* create all the necessary types and entities. Note that the + types must have a fixed layout, because we already running in the + backend */ + uint_type = new_type_primitive(IDENT("__uint"), mode_Iu); + set_type_alignment_bytes(uint_type, get_type_size_bytes(uint_type)); + + array_type = new_type_array(IDENT("__block_info_array"), 1, uint_type); set_array_bounds_int(array_type, 0, 0, n_blocks); + set_type_size_bytes(array_type, n_blocks * get_mode_size_bytes(mode_Iu)); + set_type_alignment_bytes(array_type, get_mode_size_bytes(mode_Iu)); + set_type_state(array_type, layout_fixed); - character_type = new_type_primitive(new_id_from_str("__char"), mode_Bs); - string_type = new_type_array(new_id_from_str("__filename"), 1, character_type); + character_type = new_type_primitive(IDENT("__char"), mode_Bs); + string_type = new_type_array(IDENT("__filename"), 1, character_type); set_array_bounds_int(string_type, 0, 0, filename_len); + set_type_size_bytes(string_type, filename_len); + set_type_alignment_bytes(string_type, 1); + set_type_state(string_type, layout_fixed); + + gtp = get_glob_type(); - cur_ident = new_id_from_str("__FIRMPROF__BLOCK_IDS"); - bblock_id = new_entity(get_glob_type(), cur_ident, array_type); + cur_ident = IDENT("__FIRMPROF__BLOCK_IDS"); + bblock_id = new_entity(gtp, cur_ident, array_type); set_entity_ld_ident(bblock_id, cur_ident); set_entity_variability(bblock_id, variability_initialized); - cur_ident = new_id_from_str("__FIRMPROF__BLOCK_COUNTS"); - bblock_counts = new_entity(get_glob_type(), cur_ident, array_type); + cur_ident = IDENT("__FIRMPROF__BLOCK_COUNTS"); + bblock_counts = new_entity(gtp, cur_ident, array_type); set_entity_ld_ident(bblock_counts, cur_ident); set_entity_variability(bblock_counts, variability_initialized); - cur_ident = new_id_from_str("__FIRMPROF__FILE_NAME"); - ent_filename = new_entity(get_glob_type(), cur_ident, string_type); + cur_ident = IDENT("__FIRMPROF__FILE_NAME"); + ent_filename = new_entity(gtp, cur_ident, string_type); set_entity_ld_ident(ent_filename, cur_ident); - for (n = get_irp_n_irgs() - 1; n >= 0; --n) { - ir_graph *irg = get_irp_irg(n); - - n_blocks += count_blocks(irg); + if (flags & profile_with_locations) { + loc_type = new_type_struct(IDENT("__location")); + loc_lineno = new_entity(loc_type, IDENT("lineno"), uint_type); + align_l = get_type_alignment_bytes(uint_type); + size = get_type_size_bytes(uint_type); + set_entity_offset(loc_lineno, 0); + + charptr_type = new_type_pointer(IDENT("__charptr"), character_type, mode_P_data); + align_n = get_type_size_bytes(charptr_type); + set_type_alignment_bytes(charptr_type, align_n); + loc_name = new_entity(loc_type, IDENT("name"), charptr_type); + size = (size + align_n - 1) & -align_n; + set_entity_offset(loc_name, size); + size += align_n; + + if (align_n > align_l) + align_l = align_n; + size = (size + align_l - 1) & -align_l; + set_type_size_bytes(loc_type, size); + set_type_state(loc_type, layout_fixed); + + loc_type = new_type_array(IDENT("__locarray"), 1, loc_type); + set_array_bounds_int(string_type, 0, 0, n_blocks); + + cur_ident = IDENT("__FIRMPROF__LOCATIONS"); + ent_locations = new_entity(gtp, cur_ident, loc_type); + set_entity_ld_ident(ent_locations, cur_ident); } /* initialize count array */ - tarval_array = alloca(sizeof(*tarval_array) * n_blocks); + NEW_ARR_A(tarval *, tarval_array, n_blocks); tv = get_tarval_null(mode_Iu); for (i = 0; i < n_blocks; ++i) { tarval_array[i] = tv; @@ -294,8 +438,15 @@ be_profile_instrument(char * filename) set_array_entity_values(ent_filename, tarval_string, filename_len); /* initialize block id array and instrument blocks */ - wd.array = tarval_array; - wd.id = 0; + wd.array = tarval_array; + wd.id = 0; + wd.tp_char = character_type; + wd.flags = flags; + if (flags & profile_with_locations) { + wd.fname_map = pmap_create(); + NEW_ARR_A(loc_entry, wd.locs, n_blocks); + } + for (n = get_irp_n_irgs() - 1; n >= 0; --n) { ir_graph *irg = get_irp_irg(n); int i; @@ -309,9 +460,8 @@ be_profile_instrument(char * filename) wd.symconst = new_r_SymConst(irg, get_irg_start_block(irg), sym, symconst_addr_ent); irg_block_walk_graph(irg, block_id_walker, NULL, &wd); - env.start_block = get_irg_start_block(irg); + start_block = get_irg_start_block(irg); env.end_block = get_irg_end_block(irg); - set_irn_link(env.start_block, get_irg_no_mem(irg)); irg_block_walk_graph(irg, fix_ssa, NULL, &env); for (i = get_Block_n_cfgpreds(endbb) - 1; i >= 0; --i) { ir_node *node = skip_Proj(get_Block_cfgpred(endbb, i)); @@ -341,12 +491,47 @@ be_profile_instrument(char * filename) } set_array_entity_values(bblock_id, tarval_array, n_blocks); + if (flags & profile_with_locations) { + /* build the initializer for the locations */ + rem = current_ir_graph; + current_ir_graph = get_const_code_irg(); + ent = get_array_element_entity(loc_type); + set_entity_variability(ent_locations, variability_constant); + for (i = 0; i < n_blocks; ++i) { + compound_graph_path *path; + tarval *tv; + ir_node *n; + + /* lineno */ + path = new_compound_graph_path(loc_type, 2); + set_compound_graph_path_array_index(path, 0, i); + set_compound_graph_path_node(path, 0, ent); + set_compound_graph_path_node(path, 1, loc_lineno); + tv = new_tarval_from_long(wd.locs[i].lineno, mode_Iu); + add_compound_ent_value_w_path(ent_locations, new_Const(mode_Iu, tv), path); + + /* name */ + path = new_compound_graph_path(loc_type, 2); + set_compound_graph_path_array_index(path, 0, i); + set_compound_graph_path_node(path, 0, ent); + set_compound_graph_path_node(path, 1, loc_name); + if (wd.locs[i].fname) { + sym.entity_p = wd.locs[i].fname; + n = new_SymConst(sym, symconst_addr_ent); + } else { + n = new_Const(mode_P_data, get_mode_null(mode_P_data)); + } + add_compound_ent_value_w_path(ent_locations, n, path); + } + pmap_destroy(wd.fname_map); + } return gen_initializer_irg(ent_filename, bblock_id, bblock_counts, n_blocks); } static void profile_node_info(void *ctx, FILE *f, const ir_node *irn) { + (void) ctx; if(is_Block(irn)) { fprintf(f, "profiled execution count: %u\n", be_profile_get_block_execcount(irn)); } @@ -371,7 +556,7 @@ unregister_vcg_hook(void) * profile info struct */ void -be_profile_read(char * filename) +be_profile_read(const char *filename) { FILE *f; char buf[8]; @@ -381,7 +566,7 @@ be_profile_read(char * filename) if(f == NULL) { return; } - printf("found profile data.\n"); + printf("found profile data '%s'.\n", filename); /* check magic */ ret = fread(buf, 8, 1, f); @@ -430,7 +615,7 @@ be_profile_has_data(void) * Get block execution count as determined be profiling */ unsigned int -be_profile_get_block_execcount(const ir_node * block) +be_profile_get_block_execcount(const ir_node *block) { execcount_t *ec, query; @@ -440,9 +625,61 @@ be_profile_get_block_execcount(const ir_node * block) query.block = get_irn_node_nr(block); ec = set_find(profile, &query, sizeof(query), get_irn_node_nr(block)); - if(ec) { + if(ec != NULL) { return ec->count; } else { + ir_fprintf(stderr, "Warning: Profile contains no data for %+F\n", + block); return 1; } } + +typedef struct _intialize_execfreq_env_t { + ir_graph *irg; + ir_exec_freq *execfreqs; + double freq_factor; +} initialize_execfreq_env_t; + +// minimal execution frequency (an execfreq of 0 confuses algos) +static const double MIN_EXECFREQ = 0.00001; + +static void initialize_execfreq(ir_node *block, void *data) { + initialize_execfreq_env_t *env = data; + double freq; + + if(block == get_irg_start_block(env->irg) + || block == get_irg_end_block(env->irg)) { + freq = 1.0; + } else { + freq = be_profile_get_block_execcount(block); + freq *= env->freq_factor; + if(freq < MIN_EXECFREQ) + freq = MIN_EXECFREQ; + } + + set_execfreq(env->execfreqs, block, freq); +} + +ir_exec_freq *be_create_execfreqs_from_profile(ir_graph *irg) +{ + ir_node *start_block; + initialize_execfreq_env_t env; + unsigned count; + + env.irg = irg; + env.execfreqs = create_execfreq(irg); + start_block = get_irg_start_block(irg); + + count = be_profile_get_block_execcount(start_block); + if(count == 0) { + // the function was never executed, so fallback to estimated freqs + free_execfreq(env.execfreqs); + + return compute_execfreq(irg, 10); + } + + env.freq_factor = 1.0 / count; + irg_block_walk_graph(irg, initialize_execfreq, NULL, &env); + + return env.execfreqs; +}