X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeprofile.c;h=fd3165bc9ef1fefd31ef615ca6ee01fcecef7fd5;hb=48f0393daa5d5a14ed7e3e32ee2b090759c9371e;hp=0bdcd9ad63f06f23644b939ecae4e963e31bdfd5;hpb=076a713d7f2542cc275d8d0dd1a9272db6a0ceb2;p=libfirm diff --git a/ir/be/beprofile.c b/ir/be/beprofile.c index 0bdcd9ad6..fd3165bc9 100644 --- a/ir/be/beprofile.c +++ b/ir/be/beprofile.c @@ -45,6 +45,7 @@ #include "beutil.h" #include "ircons.h" #include "irhooks.h" +#include "iredges.h" #include "bechordal_t.h" @@ -55,10 +56,20 @@ #include "beprofile.h" +/** An entry in the id-to-location map */ +typedef struct loc_entry { + 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 { @@ -77,7 +88,6 @@ block_counter(ir_node * bb, void * data) { unsigned int *count = data; *count = *count + 1; - } static unsigned int @@ -100,27 +110,72 @@ static void instrument_block(ir_node * bb, ir_node * address, unsigned int id) { ir_graph *irg = get_irn_irg(bb); - ir_node *start_block = get_irg_start_block(irg); - ir_node *load, *store, *offset, *add, *projm, *proji; - ir_node *cnst; - + ir_node *start_block = get_irg_start_block(irg); + ir_node *load, *store, *offset, *add, *projm, *proji, *unknown; + ir_node *cnst; + + /** + * We can't instrument the start and end block as there are no real + * instructions in these blocks + */ if(bb == start_block || bb == get_irg_end_block(irg)) return; - cnst = new_r_Const_long(irg, start_block, mode_Iu, get_mode_size_bytes(mode_Iu) * id); - offset = new_r_Add(irg, bb, address, cnst, mode_P); - load = new_r_Load(irg, bb, new_NoMem(), offset, mode_Iu); - projm = new_r_Proj(irg, bb, load, mode_M, pn_Load_M); - proji = new_r_Proj(irg, bb, load, mode_Iu, pn_Load_res); - cnst = new_r_Const_long(irg, start_block, mode_Iu, 1); - add = new_r_Add(irg, bb, proji, cnst, mode_Iu); - store = new_r_Store(irg, bb, projm, offset, add); - projm = new_r_Proj(irg, bb, store, mode_M, pn_Store_M); - keep_alive(projm); + unknown = new_r_Unknown(irg, mode_M); + cnst = new_r_Const_long(irg, start_block, mode_Iu, get_mode_size_bytes(mode_Iu) * id); + offset = new_r_Add(irg, bb, address, cnst, mode_P); + load = new_r_Load(irg, bb, unknown, offset, mode_Iu); + projm = new_r_Proj(irg, bb, load, mode_M, pn_Load_M); + proji = new_r_Proj(irg, bb, load, mode_Iu, pn_Load_res); + cnst = new_r_Const_long(irg, start_block, mode_Iu, 1); + add = new_r_Add(irg, bb, proji, cnst, mode_Iu); + store = new_r_Store(irg, bb, projm, offset, add); + projm = new_r_Proj(irg, bb, store, mode_M, pn_Store_M); + set_irn_link(bb, projm); + set_irn_link(projm, load); +} + +typedef struct fix_env { + ir_node *start_block; + ir_node *end_block; +} fix_env; + +/** + * SSA Construction for instrumentation code memory + */ +static void +fix_ssa(ir_node * bb, void * data) +{ + fix_env *env = data; + ir_node *mem; + int arity = get_Block_n_cfgpreds(bb); + + /* start and end block are not instrumented, skip! */ + if (bb == env->start_block || bb == env->end_block) + return; + + if (arity == 1) { + mem = get_irn_link(get_Block_cfgpred_block(bb, 0)); + } else { + int n; + ir_node **ins; + ir_graph *irg = current_ir_graph; + + NEW_ARR_A(ir_node*, ins, arity); + for (n = arity - 1; n >= 0; --n) { + ins[n] = get_irn_link(get_Block_cfgpred_block(bb, n)); + } + mem = new_r_Phi(irg, bb, arity, ins, mode_M); + } + set_Load_mem(get_irn_link(get_irn_link(bb)), mem); } + /** * Generates a new irg which calls the initializer + * + * Pseudocode: + * 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) @@ -155,7 +210,6 @@ gen_initializer_irg(entity * ent_filename, entity * bblock_id, entity * bblock_c set_entity_ld_ident(init_ent, init_name); irg = new_ir_graph(ent, 0); - set_current_ir_graph(irg); empty_frame_type = get_irg_frame_type(irg); set_type_size_bytes(empty_frame_type, 0); @@ -186,6 +240,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); + 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) { @@ -193,56 +300,114 @@ 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; - int filename_len = strlen(filename)+1; - ident *cur_ident; - + int n, i; + unsigned int n_blocks = 0; + entity *bblock_id; + entity *bblock_counts; + entity *ent_filename; + entity *ent_locations = NULL; + entity *loc_lineno = NULL; + entity *loc_name = NULL; + 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; + 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); - 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); - cur_ident = new_id_from_str("__FIRMPROF__BLOCK_IDS"); - bblock_id = new_entity(get_glob_type(), cur_ident, array_type); + gtp = get_glob_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); - set_entity_variability(ent_filename, variability_initialized); - 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_bytes(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_bytes(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] = get_tarval_null(mode_Iu); + tarval_array[i] = tv; } set_array_entity_values(bblock_counts, tarval_array, n_blocks); @@ -251,23 +416,98 @@ be_profile_instrument(char * filename) for (i = 0; i < filename_len; ++i) { tarval_string[i] = new_tarval_from_long(filename[i], mode_Bs); } + set_entity_variability(ent_filename, variability_constant); 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); + ir_graph *irg = get_irp_irg(n); + int i; + ir_node *endbb = get_irg_end_block(irg); + fix_env env; + + set_current_ir_graph(irg); /* generate a symbolic constant pointing to the count array */ sym.entity_p = bblock_counts; 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); + 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)); + ir_node *bb = get_Block_cfgpred_block(endbb, i); + ir_node *sync; + ir_node *ins[2]; + + switch (get_irn_opcode(node)) { + case iro_Return: + ins[0] = get_irn_link(bb); + ins[1] = get_Return_mem(node); + sync = new_r_Sync(irg, bb, 2, ins); + set_Return_mem(node, sync); + break; + case iro_Raise: + ins[0] = get_irn_link(bb); + ins[1] = get_Raise_mem(node); + sync = new_r_Sync(irg, bb, 2, ins); + set_Raise_mem(node, sync); + break; + default: + /* a fragile's op exception. There should be another path to End, + so ignore it */ + assert(is_fragile_op(node) && "unexpected End control flow predecessor"); + } + } } 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); } @@ -298,7 +538,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]; @@ -308,7 +548,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); @@ -345,7 +585,7 @@ be_profile_free(void) } /** - * Tells whether profile module has aquired data + * Tells whether profile module has acquired data */ int be_profile_has_data(void) @@ -357,7 +597,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; @@ -367,9 +607,73 @@ 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 *block2 = NULL; + ir_node *start_block; + const ir_edge_t *edge; + initialize_execfreq_env_t env; + unsigned count; + + env.irg = irg; + env.execfreqs = create_execfreq(irg); + + // find the successor to the start block + start_block = get_irg_start_block(irg); + foreach_block_succ(start_block, edge) { + ir_node *succ = get_edge_src_irn(edge); + if(succ != start_block) { + block2 = succ; + break; + } + } + assert(block2 != NULL); + + count = be_profile_get_block_execcount(block2); + 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; +}