-double get_irg_callee_execution_freqency(ir_graph *irg, int pos) {
+double get_irg_callee_execution_frequency(ir_graph *irg, int pos) {
ir_node **arr = ((ana_entry *)irg->callees[pos])->call_list;
int i, n_Calls = ARR_LEN(arr);
double freq = 0;
return freq;
}
-double get_irg_callee_method_execution_freqency(ir_graph *irg, int pos) {
- double call_freq = get_irg_callee_execution_freqency(irg, pos);
+double get_irg_callee_method_execution_frequency(ir_graph *irg, int pos) {
+ double call_freq = get_irg_callee_execution_frequency(irg, pos);
double meth_freq = get_irg_method_execution_frequency(irg);
return call_freq * meth_freq;
}
-double get_irg_caller_method_execution_freqency(ir_graph *irg, int pos) {
+double get_irg_caller_method_execution_frequency(ir_graph *irg, int pos) {
ir_graph *caller = get_irg_caller(irg, pos);
int pos_callee = reverse_pos(irg, pos);
- return get_irg_callee_method_execution_freqency(caller, pos_callee);
+ return get_irg_callee_method_execution_frequency(caller, pos_callee);
}
/* ----------------------------------------------------------------------------------- */
-/* Another algorithm to compute recursion nesting depth */
-/* Walk the callgraph. Ignore backedges. Use sum of execution freqencies of Call */
+/* Another algorithm to compute the execution frequency of methods ignoring recursions. */
+/* Walk the callgraph. Ignore backedges. Use sum of execution frequencies of Call */
/* nodes to evaluate a callgraph edge. */
/* ----------------------------------------------------------------------------------- */
void set_irg_method_execution_frequency (ir_graph *irg, double freq) {
irg->method_execution_frequency = freq;
+
+ if (irp->max_method_execution_frequency < freq)
+ irp->max_method_execution_frequency = freq;
}
static void compute_method_execution_frequency (ir_graph *irg, void *env) {
+ int i, n_callers;
+ double freq;
+ int found_edge;
+ int n_callees;
+
if (cg_irg_visited(irg)) return;
/* We need the values of all predecessors (except backedges).
So they must be marked. Else we will reach the node through
one of the unmarked ones. */
- int i, n_callers = get_irg_n_callers(irg);
+ n_callers = get_irg_n_callers(irg);
for (i = 0; i < n_callers; i++) {
ir_graph *m = get_irg_caller(irg, i);
if (is_irg_caller_backedge(irg, i)) continue;
}
mark_cg_irg_visited(irg);
- /* Compute the new freqency. */
- double freq = 0;
- int found_edge = 0;
+ /* Compute the new frequency. */
+ freq = 0;
+ found_edge = 0;
for (i = 0; i < n_callers; i++) {
- if (is_irg_caller_backedge(irg, i)) continue;
- double edge_freq = get_irg_caller_method_execution_freqency(irg, i);
- assert(edge_freq >= 0);
- freq += edge_freq;
- found_edge = 1;
+ if (! is_irg_caller_backedge(irg, i)) {
+ double edge_freq = get_irg_caller_method_execution_frequency(irg, i);
+ assert(edge_freq >= 0);
+ freq += edge_freq;
+ found_edge = 1;
+ }
}
if (!found_edge) {
set_irg_method_execution_frequency(irg, freq);
/* recur */
- int n_callees = get_irg_n_callees(irg);
+ n_callees = get_irg_n_callees(irg);
for (i = 0; i < n_callees; i++) {
compute_method_execution_frequency (get_irg_callee(irg, i), NULL);
}
DEL_ARR_F(e.loop_stack);
- //dump_callgraph("-with_nesting");
- //dump_callgraph_loop_tree(current_loop, "-after_cons");
-
-
/* -- compute the execution frequency -- */
irp->max_method_execution_frequency = 0;
master_cg_visited += 2;
find_callgraph_recursions();
compute_performance_estimates();
+
+ set_irp_loop_nesting_depth_state(loop_nesting_depth_consistent);
+}
+
+
+loop_nesting_depth_state get_irp_loop_nesting_depth_state(void) {
+ return irp->lnd_state;
+}
+void set_irp_loop_nesting_depth_state(loop_nesting_depth_state s) {
+ irp->lnd_state = s;
+}
+void set_irp_loop_nesting_depth_state_inconsistent(void) {
+ if (irp->lnd_state == loop_nesting_depth_consistent)
+ irp->lnd_state = loop_nesting_depth_inconsistent;
}