6 #ifndef complexity_header_included
7 #define complexity_header_included
47 #define COMPLEXITY_PACKAGE_NAME "COMPLEXITY"
48 #define COMPLEXITY_UNDEFINED complexity_undefined
52 #define COMPLEXITY_UNDEFINED_P(c) ((c)==complexity_undefined)
53 #define COMPLEXITY_NOT_FOUND ((complexity) HASH_UNDEFINED_VALUE)
55 #define MAX_CONTROLS_IN_UNSTRUCTURED 100
58 #define UNKNOWN_VARIABLE_NAME "UNKNOWN_VARIABLE"
61 #define UNKNOWN_RANGE_NAME "UNKNOWN_RANGE"
63 #define TCST_NAME "_TCST_"
68 #define UNKNOWN_VARIABLE_VALUE_PREFIX "U_"
71 #define COST_DATA "operation index memory trigo transcend overhead"
74 #define DO_PRINT_STATS true
75 #define DONT_PRINT_STATS false
76 #define PRINT_LOCAL_NAMES true
77 #define PRINT_GLOBAL_NAMES false
79 #define HASH_LOOP_INDEX ((char *) 4)
80 #define HASH_USER_VARIABLE ((char *) 8)
81 #define HASH_FORMAL_PARAM ((char *) 12)
82 #define HASH_COMMON_VARIABLE ((char *) 16)
86 #define FLOAT_NBYTES 4
87 #define DOUBLE_NBYTES 8
88 #define COMPLEX_NBYTES 2*FLOAT_NBYTES
89 #define DCOMPLEX_NBYTES 2*DOUBLE_NBYTES
90 #define MAKE_INT_BASIC make_basic(is_basic_int, (void *) INT_NBYTES)
91 #define MAKE_ADDRESS_BASIC make_basic(is_basic_int, (void *) DEFAULT_POINTER_TYPE_SIZE)
92 #define MAKE_FLOAT_BASIC make_basic(is_basic_float, (void *) FLOAT_NBYTES)
93 #define MAKE_DOUBLE_BASIC make_basic(is_basic_float, (void *) DOUBLE_NBYTES)
94 #define MAKE_COMPLEX_BASIC make_basic(is_basic_complex, (void *) COMPLEX_NBYTES)
95 #define MAKE_DCOMPLEX_BASIC make_basic(is_basic_complex, (void *) DCOMPLEX_NBYTES)
96 #define MAKE_STRING_BASIC make_basic(is_basic_string, make_value(is_value_unknown, UU))
98 #define hash_contains_p(htp, key) (hash_get(htp, key) != HASH_UNDEFINED_VALUE)
99 #define hash_contains_formal_param_p(htp, key) (hash_get(htp, key) == HASH_FORMAL_PARAM)
100 #define hash_contains_user_var_p(htp, key) (hash_get(htp, key) == HASH_USER_VARIABLE)
101 #define hash_contains_common_var_p(htp, key) (hash_get(htp, key) == HASH_COMMON_VARIABLE)
102 #define hash_contains_loop_index_p(htp, key) (hash_get(htp, key) == HASH_LOOP_INDEX)
106 #define KEEP_SYMBOLS true
107 #define DONT_KEEP_SYMBOLS false
108 #define MAXIMUM_VALUE 1
109 #define MINIMUM_VALUE -1
110 #define EXACT_VALUE 0
111 #define TAKE_MAX(m) ((m) == MAXIMUM_VALUE)
112 #define TAKE_MIN(m) ((m) == MINIMUM_VALUE)
113 #define KEEP_EXACT(m) ((m) == EXACT_VALUE)
128 #define LOOP_INIT_OVERHEAD "LOOP-INIT-OVERHEAD"
129 #define LOOP_BRANCH_OVERHEAD "LOOP-BRANCH-OVERHEAD"
130 #define CONDITION_OVERHEAD "CONDITION-OVERHEAD"
132 #define CALL_ZERO_OVERHEAD "CALL-ZERO-OVERHEAD"
133 #define CALL_ONE_OVERHEAD "CALL-ONE-OVERHEAD"
134 #define CALL_TWO_OVERHEAD "CALL-TWO-OVERHEAD"
135 #define CALL_THREE_OVERHEAD "CALL-THREE-OVERHEAD"
136 #define CALL_FOUR_OVERHEAD "CALL-FOUR-OVERHEAD"
137 #define CALL_FIVE_OVERHEAD "CALL-FIVE-OVERHEAD"
138 #define CALL_SIX_OVERHEAD "CALL-SIX-OVERHEAD"
139 #define CALL_SEVEN_OVERHEAD "CALL-SEVEN-OVERHEAD"
142 #define TYPE_CAST_COST "TypeCast"
147 #define MEMORY_READ_NAME "MEMORY-READ"
148 #define ONE_INDEX_NAME "ONE-INDEX"
149 #define TWO_INDEX_NAME "TWO-INDEX"
150 #define THREE_INDEX_NAME "THREE-INDEX"
151 #define FOUR_INDEX_NAME "FOUR-INDEX"
152 #define FIVE_INDEX_NAME "FIVE-INDEX"
153 #define SIX_INDEX_NAME "SIX-INDEX"
154 #define SEVEN_INDEX_NAME "SEVEN-INDEX"
155 #define STRING_INTRINSICS_COST 1
156 #define LOGICAL_INTRINSICS_COST 1
158 #define DONT_COUNT_THAT 0, 0, 0, 0, 0
159 #define EMPTY_COST 0,0,0,0,0
160 #define DISCRIMINE_TYPES 1, 10, 100,1000,10000
161 #define REAL_INTRINSIC 100, 100, 100, 100, 100
162 #define DOUBLE_INTRINSIC 200, 200, 200, 200, 200
163 #define COMPLEX_INTRINSIC 400, 400, 400, 400, 400
165 #define MEMORY_READ_COST DONT_COUNT_THAT
166 #define MEMORY_WRITE_COST DONT_COUNT_THAT
167 #define PLUS_MINUS_COST 1, 10, 20, 20, 40
172 #define MULTIPLY_COST PLUS_MINUS_COST
173 #define DIVIDE_COST PLUS_MINUS_COST
174 #define POWER_COST 100, 100, 200, 200, 400
176 #define TRANSC_COST REAL_INTRINSIC
177 #define DTRANSC_COST DOUBLE_INTRINSIC
178 #define CTRANSC_COST COMPLEX_INTRINSIC
179 #define TRIGO_COST REAL_INTRINSIC
180 #define DTRIGO_COST DOUBLE_INTRINSIC
181 #define CTRIGO_COST COMPLEX_INTRINSIC
182 #define TRIGOH_COST REAL_INTRINSIC
183 #define DTRIGOH_COST DOUBLE_INTRINSIC
184 #define CTRIGOH_COST COMPLEX_INTRINSIC
186 #define TWO_INDEX_COST DONT_COUNT_THAT
187 #define THREE_INDEX_COST DONT_COUNT_THAT
188 #define FOUR_INDEX_COST DONT_COUNT_THAT
189 #define FIVE_INDEX_COST DONT_COUNT_THAT
190 #define SIX_INDEX_COST DONT_COUNT_THAT
191 #define SEVEN_INDEX_COST DONT_COUNT_THAT
complexity unstructured_to_complexity(unstructured, transformer, list)
comp_unstr.c
char * complexity_sprint(complexity, bool, bool)
hash_table fetch_complexity_parameters(char *)
hash_table hash_complexity_parameters
void complexity_div(complexity *, complexity)
void complexity_div(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 / comp2; !...
complexity complexity_sigma(complexity, Variable, complexity, complexity)
comp_math.c
complexity statement_to_complexity(statement, transformer, list)
void add_formal_parameters_to_hash_table(entity, hash_table)
complexity reference_to_complexity(reference, basic *, transformer, list)
1st element of syntax
complexity indices_to_complexity(list, basic *, transformer, list)
2nd element of reference
bool summary_complexity(const string)
complexity polynome_to_new_complexity(Ppolynome)
Create a complexity equal to Ppolynome pp with null statistics.
void update_statement_complexity(statement, complexity)
void add_common_variables_to_hash_table(entity, hash_table)
int control_element_position_in_control_array(control, control[], int)
bool print_icfg_with_loops_complexities(const string)
void complexity_scalar_mult(complexity *, double)
hash_table hash_callee_to_complexity
cproto-generated files
bool complexity_unknown_p(complexity)
true if comp is unknown.
complexity syntax_to_complexity(syntax, basic *, transformer, list)
the only available element of expression
Variable local_name_to_variable(char *)
complexity unary_plus_op_handler(list, transformer, list, bool, int)
void complexity_float_add(complexity *, double)
bool print_source_complexities(const string)
complexity loop_to_complexity(loop, transformer, list)
3rd element of instruction
complexity make_complexity_unknown(const char *)
builds a new unknown complexity attached to a virtual package
matrice average_probability_matrix(unstructured, int, control[])
void fprint_cost_table(FILE *)
complexity goto_to_complexity(statement, transformer, list)
void complexity_add(complexity *, complexity)
void complexity_add(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 + comp2; !...
void node_successors_to_matrix(control, matrice, int, control[], bool[])
complexity cast_to_polynome(cast, transformer, list, bool, int)
4th element of syntax : Molka Becher
complexity call_to_polynome(call, transformer, list, bool, int)
3rd element of syntax
complexity make_zero_complexity(void)
make a zero complexity "0.0000 * TCST" with null statistics
void complexity_sub(complexity *, complexity)
void complexity_sub(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 - comp2; !...
statement_mapping get_complexity_map(void)
int is_inferior_varval(Pvecteur, Pvecteur)
bool fp_complexities(const string)
char * variable_name(Variable)
polynome_ri.c
complexity multiply_op_handler(list, transformer, list, bool, int)
complexity test_to_complexity(test, transformer, list)
2nd element of instruction
complexity normalized_to_polynome(normalized, transformer, list, bool, int)
2nd element of expression
bool print_code_as_a_graph_complexities(const string)
complexity complexity_var_subst(complexity, Variable, complexity)
complexity complexity_var_subst(comp, var, compsubst) replaces every occurrence of variable var in co...
char * variable_local_name(Variable)
void make_complexity_map(void)
hash_table free_callees_complexities(hash_table)
void store_statement_complexity(statement, complexity)
bool uniform_complexities(const string)
declares the static variable complexity_map and defines its access functions
Ppolynome complexity_polynome(complexity)
Because complexity is composed of two elements, we use this function to get the first element : polyn...
void complexity_polynome_add(complexity *, Ppolynome)
bool complexity_check(complexity)
comp_util.c
complexity whileloop_to_complexity(whileloop, transformer, list)
5th element of instruction
Variable name_to_variable(char *)
complexity unary_minus_op_handler(list, transformer, list, bool, int)
complexity syntax_to_polynome(syntax, transformer, list, bool, int)
1st element of expression
complexity block_to_complexity(list, transformer, list)
1st element of instruction
complexity power_op_handler(list, transformer, list, bool, int)
bool is_must_be_written_var(list, char *)
complexity field_op_handler(list, transformer, list, bool, int)
complexity divide_op_handler(list, transformer, list, bool, int)
bool any_complexities(const string)
bool print_call_graph_with_complexities(const string)
complexity plus_op_handler(list, transformer, list, bool, int)
void complexity_dump(complexity)
complexity final_statement_to_complexity_evaluation(complexity, transformer, list)
complexity simplify_sc_to_complexity(Psysteme, Variable)
This function is recently added by L.Zhou June 5, 91 simplify_sc_to_complexity(Psysteme ps,...
void complexity_mult(complexity *, complexity)
void complexity_mult(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 * comp2; !...
complexity complexity_dup(complexity)
duplicates complexity comp
complexity minus_op_handler(list, transformer, list, bool, int)
void init_cost_table(void)
Completes the intrinsic cost table with the costs read from the files specified in the "COMPLEXITY_CO...
void complexity_check_and_warn(const char *, complexity)
complexity make_single_var_complexity(double, Variable)
bool is_linear_unstructured(unstructured)
return true if unstr is simply a linear string of controls
void good_complexity_assert(string, complexity)
bool print_icfg_with_complexities(const string)
void load_cost_file(FILE *, double)
bool complexity_constant_p(complexity)
true if comp is constant.
void controls_to_hash_table(control, int *, control[], hash_table, transformer, list)
void remove_common_variables_from_hash_table(entity, hash_table)
complexity range_to_complexity(range, transformer, list)
2nd element of syntax
complexity range_to_polynome(range, transformer, list, bool, int)
void trace_on(char *,...)
complexity call_to_complexity(call, basic *, transformer, list)
3rd element of syntax
int intrinsic_cost(const char *, basic *)
int is_inferior_pvarval(Pvecteur *, Pvecteur *)
complexity load_statement_complexity(statement)
intrinsic_cost_record intrinsic_cost_table[]
The table intrinsic_cost_table[] gathers cost information of each intrinsic's cost; those costs are d...
void reset_complexity_map(void)
complexity expression_to_complexity(expression, basic *, transformer, list)
2nd element of call –arguments
float complexity_TCST(complexity)
return the constant term of comp.
list entity_list_reverse(list)
void lu_decomposition(float *, int, int *, int *)
comp_matrice.c
bool is_inferior_var(Variable, Variable)
complexity make_constant_complexity(double)
void lu_back_substitution(float *, int, int *, float *)
void complexity_stats_add(complexity *, complexity)
Add comp2's statistics to *pcomp1's comp2 keeps unchanged.
complexity pvecteur_to_polynome(Pvecteur, transformer, list, bool, int)
The only element available of normalized.
void trace_off(void)
"trace off"
void float_matrice_inversion(float *, int, int *, int *)
complexity arguments_to_complexity(list, basic *, transformer, list)
2nd element of call
list list_ith_element(list, int)
return a pointer to the (i)th element of the list if i = 1, the pointer doesn't change at all.
bool print_code_complexities(const string)
comp_prettyprint.c
hash_table fetch_callees_complexities(char *)
complexity expression_to_complexity_polynome(expression, transformer, list, bool, int)
Entry point routine of this file:
bool complexity_is_monomial_p(complexity)
complexity instruction_to_complexity(instruction, transformer, list)
The only element available of the statement.
bool print_icfg_with_control_complexities(const string)
complexity translate_complexity_from_local_to_current_name(complexity, string, string)
translate_complexity_from_local_to_current_name(callee_comp,oldname,newname) B:M -> A:M if A calls B ...
float constant_entity_to_float(entity)
Return if possible the value of e in a float.
complexity subscript_to_complexity(subscript, basic *, transformer, list)
void complexity_rm(complexity *)
remove complexity comp
void fprint_statement_complexity(entity, statement, hash_table)
int complexity_degree(complexity)
void free_complexity_map(void)
bool statement_complexity_undefined_p(statement)
void complexity_fprint(FILE *, complexity, bool, bool)
complexity evaluate_var_to_complexity(entity, transformer, list, int)
void set_complexity_map(statement_mapping)
bool complexity_map_undefined_p(void)
bool complexity_zero_p(complexity)
zero complexity check.
complexity reference_to_polynome(reference, transformer, list, bool, int)
First element of the "syntax" domain.
complexity replace_formal_parameters_by_real_ones(complexity, entity, list, transformer, list)
transform formal params into real ones (args) in complexity comp
void delete_statement_complexity(statement)
struct intrinsic_cost_rec intrinsic_cost_record
Intrinsics costs defines.
char * noms_var(entity)
comp_expr_to_pnome.c
void remove_formal_parameters_from_hash_table(entity, hash_table)
Value * matrice
package matrice
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
The structure used to build lists in NewGen.
Intrinsics costs defines.
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....