X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Ffield_temperature.c;h=c179f07ac47cf86331189a540693faddb581e2eb;hb=095f85e9278da3c5972202d0ee1c87326c28f75d;hp=53d526bf25364649f49dc20e4fca3303f595d60b;hpb=25ecc359b5e533bbd528cc920b2e59788e41ce10;p=libfirm diff --git a/ir/ana/field_temperature.c b/ir/ana/field_temperature.c index 53d526bf2..c179f07ac 100644 --- a/ir/ana/field_temperature.c +++ b/ir/ana/field_temperature.c @@ -29,7 +29,6 @@ /* initialize, global variables. */ /* *************************************************************************** */ - /* *************************************************************************** */ /* Access routines for irnodes */ /* *************************************************************************** */ @@ -43,8 +42,6 @@ entity *get_Sel_accessed_entity(ir_node *sel, int pos) { return get_Sel_entity(sel); } - - /* *************************************************************************** */ /* The heuristic */ /* *************************************************************************** */ @@ -54,7 +51,7 @@ int get_irn_loop_call_depth(ir_node *n) { return get_irg_loop_depth(irg); } -int get_irn_loop_depth(ir_node *n) { +int get_irn_cfloop_depth(ir_node *n) { ir_loop *l = get_irn_loop(get_nodes_block(n)); if (l) return get_loop_depth(l); @@ -68,9 +65,10 @@ int get_irn_recursion_depth(ir_node *n) { } +/** @@@ the second version of the heuristic. */ int get_weighted_loop_depth(ir_node *n) { int loop_call_depth = get_irn_loop_call_depth(n); - int loop_depth = get_irn_loop_depth(n); + int loop_depth = get_irn_cfloop_depth(n); int recursion_depth = get_irn_recursion_depth(n); return loop_call_depth + loop_depth + recursion_depth; @@ -83,18 +81,32 @@ int get_weighted_loop_depth(ir_node *n) { static int default_recursion_weight = 5; - /* The final evaluation of a node. In this function we can - adapt the heuristic. Combine execution freqency with - recursion depth. */ + adapt the heuristic. Combine execution frequency with + recursion depth. + @@@ the second version of the heuristic. + + Return 0 if the node is neither in a loop nor in a recursion. */ double get_irn_final_cost(ir_node *n) { - double cost_loop = get_irn_exec_freq(n); - int rec_depth = get_irn_recursion_depth(n); - double cost_rec = pow(default_recursion_weight, rec_depth); - return cost_loop + cost_rec; + double cost_loop = get_irn_exec_freq(n); + double cost_method = get_irg_method_execution_frequency(get_irn_irg(n)); + int rec_depth = get_irn_recursion_depth(n); + double cost_rec = 0; + +#if 0 + if (get_irn_recursion_depth(n) == 0 && + get_irn_loop_depth(n) == 0 && + get_irg_method_loop_depth(get_irn_irg(n)) == 0) + return 0; +#else + if (get_weighted_loop_depth(n) == 0) return 0; +#endif + + if (rec_depth) cost_rec = pow(default_recursion_weight, rec_depth); + return cost_loop*(cost_method + cost_rec); } -double get_type_estimated_n_instances(type *tp) { +double get_type_estimated_n_instances(ir_type *tp) { int i, n_allocs = get_type_n_allocs(tp); double n_instances = 0; for (i = 0; i < n_allocs; ++i) { @@ -104,11 +116,12 @@ double get_type_estimated_n_instances(type *tp) { return n_instances; } -double get_type_estimated_mem_consumption_bytes(type *tp) { +double get_type_estimated_mem_consumption_bytes(ir_type *tp) { assert(0); + return 0.0; } -int get_type_estimated_n_fields(type *tp) { +int get_type_estimated_n_fields(ir_type *tp) { int s = 0; switch(get_type_tpop_code(tp)) { @@ -147,7 +160,7 @@ int get_type_estimated_n_fields(type *tp) { return s; } -int get_type_estimated_size_bytes(type *tp) { +int get_type_estimated_size_bytes(ir_type *tp) { int s = 0; switch(get_type_tpop_code(tp)) { @@ -159,7 +172,7 @@ int get_type_estimated_size_bytes(type *tp) { break; case tpo_class: - s = get_mode_size_bytes(mode_P_mach); /* dispatch pointer */ + s = get_mode_size_bytes(mode_P_data); /* dispatch pointer */ /* fall through */ case tpo_struct: { int i, n_mem = get_compound_n_members(tp); @@ -190,7 +203,7 @@ int get_type_estimated_size_bytes(type *tp) { return s; } -double get_type_estimated_n_casts(type *tp) { +double get_type_estimated_n_casts(ir_type *tp) { int i, n_casts = get_type_n_casts(tp); double n_instances = 0; for (i = 0; i < n_casts; ++i) { @@ -200,7 +213,7 @@ double get_type_estimated_n_casts(type *tp) { return n_instances; } -double get_class_estimated_n_upcasts(type *clss) { +double get_class_estimated_n_upcasts(ir_type *clss) { double n_instances = 0; int i, j, n_casts, n_pointertypes; @@ -221,7 +234,7 @@ double get_class_estimated_n_upcasts(type *clss) { return n_instances; } -double get_class_estimated_n_downcasts(type *clss) { +double get_class_estimated_n_downcasts(ir_type *clss) { double n_instances = 0; int i, j, n_casts, n_pointertypes; @@ -243,12 +256,12 @@ double get_class_estimated_n_downcasts(type *clss) { } -double get_class_estimated_dispatch_writes(type *clss) { +double get_class_estimated_dispatch_writes(ir_type *clss) { return get_type_estimated_n_instances(clss); } /** Returns the number of reads of the dispatch pointer. */ -double get_class_estimated_dispatch_reads (type *clss) { +double get_class_estimated_dispatch_reads (ir_type *clss) { int i, n_mems = get_class_n_members(clss); double n_calls = 0; for (i = 0; i < n_mems; ++i) { @@ -258,7 +271,7 @@ double get_class_estimated_dispatch_reads (type *clss) { return n_calls; } -double get_class_estimated_n_dyncalls(type *clss) { +double get_class_estimated_n_dyncalls(ir_type *clss) { return get_class_estimated_dispatch_reads(clss) + get_class_estimated_dispatch_writes(clss); } @@ -306,19 +319,18 @@ double get_entity_estimated_n_dyncalls(entity *ent) { ir_node *acc = get_entity_access(ent, i); /* Call->Sel(ent) combination */ - if ((get_irn_op(acc) == op_Call) && - (get_irn_op(get_Call_ptr(acc)) == op_Sel)) { + if (is_Call(acc) && is_Sel(get_Call_ptr(acc))) { n_calls += get_irn_final_cost(acc); /* MemOp->Sel combination for static, overwritten entities */ - } else if (is_memop(acc) && (get_irn_op(get_memop_ptr(acc)) == op_Sel)) { + } else if (is_memop(acc) && is_Sel(get_memop_ptr(acc))) { entity *ent = get_Sel_entity(get_memop_ptr(acc)); if (is_Class_type(get_entity_owner(ent))) { - /* We might call this for inner entities in compounds. */ - if (get_entity_n_overwrites(ent) > 0 || - get_entity_n_overwrittenby(ent) > 0) { - n_calls += get_irn_final_cost(acc); - } + /* We might call this for inner entities in compounds. */ + if (get_entity_n_overwrites(ent) > 0 || + get_entity_n_overwrittenby(ent) > 0) { + n_calls += get_irn_final_cost(acc); + } } } @@ -326,13 +338,17 @@ double get_entity_estimated_n_dyncalls(entity *ent) { return n_calls; } - -/* *************************************************************************** */ -/* Auxiliary */ -/* *************************************************************************** */ +/* ------------------------------------------------------------------------- */ +/* Auxiliary */ +/* ------------------------------------------------------------------------- */ int is_jack_rts_name(ident *name) { + if (id_is_suffix(new_id_from_str("Exception"), name)) return 1; + if (id_is_suffix(new_id_from_str("Throwable"), name)) return 1; + if (id_is_suffix(new_id_from_str("Error"), name)) return 1; + return 0; + if (id_is_prefix(new_id_from_str("java/"), name)) return 1; if (id_is_prefix(new_id_from_str("["), name)) return 1; if (id_is_prefix(new_id_from_str("gnu/"), name)) return 1; @@ -343,7 +359,7 @@ int is_jack_rts_name(ident *name) { } -int is_jack_rts_class(type *t) { +int is_jack_rts_class(ir_type *t) { ident *name = get_type_ident(t); return is_jack_rts_name(name); }