void **pdeq_copyr(pdeq *qp, const void **dst);
/**
- * Add a pointer to the left site of a double ended pointer list.
+ * Add a pointer to the left side of a double ended pointer list.
*
* @param dq The list to add a pointer to.
* @param x The pointer element to be added
pdeq *pdeq_putl(pdeq *dq, const void *x);
/**
- * Add a pointer to the right site of a double ended pointer list.
+ * Add a pointer to the right side of a double ended pointer list.
*
* @param dq The list to add a pointer to.
* @param x The pointer element to be added
-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 the execution freqency of methods ignoring recursions. */
-/* 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. */
/* ----------------------------------------------------------------------------------- */
}
mark_cg_irg_visited(irg);
- /* Compute the new freqency. */
+ /* Compute the new frequency. */
freq = 0;
found_edge = 0;
for (i = 0; i < n_callers; i++) {
if (! is_irg_caller_backedge(irg, i)) {
- double edge_freq = get_irg_caller_method_execution_freqency(irg, i);
+ double edge_freq = get_irg_caller_method_execution_frequency(irg, i);
assert(edge_freq >= 0);
freq += edge_freq;
found_edge = 1;
* path from main().
* - The recursion depth. The maximal number of recursions passed
* on all paths reaching this method.
- * - The execution freqency. As loop depth, but the edge weight is the sum
- * of the execution freqencies of all Calls along the edge.
+ * - The execution frequency. As loop depth, but the edge weight is the sum
+ * of the execution frequencies of all Calls along the edge.
**/
void compute_performance_estimates(void);
/*--------------------------------------------------------------------------*/
/** Returns the entity that contains the implementation of the inherited
- entity if available, else returns the entity passed. */
+ * entity if available, else returns the entity passed. */
static entity *get_inherited_methods_implementation(entity *inh_meth) {
assert(get_atomic_ent_value(inh_meth) && "constant entity without value");
assert((get_irn_op(get_atomic_ent_value(inh_meth)) == op_SymConst) &&