6 #ifndef reductions_header_included
7 #define reductions_header_included
35 #define reduction_variable(r) reference_variable(reduction_reference(r))
36 #define reduction_none_p(r) reduction_operator_none_p(reduction_op(r))
37 #define reduction_tag(r) reduction_operator_tag(reduction_op(r))
38 #define make_none_reduction(var) \
39 make_reduction(make_reference(var, NIL), \
40 make_reduction_operator(is_reduction_operator_none, UU),\
45 #define DEBUG_REDUCTION(level, msg, red) \
46 ifdebug(level){pips_debug(level, msg); print_reduction(red);}
47 #define DEBUG_REDUCTIONS(level, msg, reds) \
48 ifdebug(level){pips_debug(level, msg); \
49 gen_map(print_reduction, reductions_list(reds));}
reductions delete_printed_reductions(statement)
void close_cumulated_reductions(void)
bool reduction_propagation(const char *)
propagation.c
bool bound_proper_reductions_p(statement)
void update_proper_reductions(statement, reductions)
bool cumulated_reductions_undefined_p(void)
bool flag_parallel_reduced_loops_with_atomic(string)
Flag loop as parallel when replacement with atomic is possible without doing the replacement.
void store_or_update_proper_reductions(statement, reductions)
void reset_cumulated_reductions(void)
void update_cumulated_reductions(statement, reductions)
void init_proper_reductions(void)
void set_printed_reductions(pstatement_reductions)
void error_reset_printed_reductions(void)
void store_printed_reductions(statement, reductions)
void remove_variable_from_reduction(reduction, entity)
void error_reset_proper_reductions(void)
bool reduction_star_p(reduction)
utils.c
bool reduction_detection(const char *)
void set_cumulated_reductions(pstatement_reductions)
void store_or_update_cumulated_reductions(statement, reductions)
void init_cumulated_reductions(void)
bool update_compatible_reduction(reduction *, entity, list, reductions)
what to do with reduction *pr for variable var under effects le and reductions reds.
bool proper_reductions_undefined_p(void)
bool flag_parallel_reduced_loops_with_openmp_directives(const char *)
Flag loop as parallel with OpenMP directives taking reductions into account.
bool cumulated_reductions(const char *)
handler for pipsmake input: the module name output: TRUE side effects: some
string reduction_operator_name(reduction_operator)
allocates and returns the name of the operator
pstatement_reductions get_printed_reductions(void)
pstatement_reductions get_proper_reductions(void)
reductions load_printed_reductions(statement)
string note_for_statement(statement)
generates a short note to tell about the type of the statement being decorated.
void close_proper_reductions(void)
void reset_printed_reductions(void)
bool omp_pragma_expr_for(loop, statement)
generate "pragma omp for" as a list of expressions
bool bound_printed_reductions_p(statement)
bool bound_cumulated_reductions_p(statement)
void store_or_update_printed_reductions(statement, reductions)
reductions delete_proper_reductions(statement)
string reductions_get_omp_pragma_str(loop, statement)
reductions load_summary_reductions(entity)
reductions.c
bool loop_reductions(string)
transformation.c
bool call_proper_reduction_p(statement, call, reduction *)
This function look for a reduction and return it if found mallocs are avoided if nothing is found....
bool no_other_effects_on_references(statement, list)
checks that the references are the only touched within this statement.
bool printed_reductions_undefined_p(void)
prettyprint.c
bool replace_reduction_with_atomic(string)
end of it
reductions load_cumulated_reductions(statement)
bool pure_function_p(entity)
extract the proper reduction of a call (instruction) if any.
void print_reduction(reduction)
void update_printed_reductions(statement, reductions)
reductions load_proper_reductions(statement)
entity reduction_operator_entity(reduction_operator)
match a reduction operator against operator entity
void reset_proper_reductions(void)
pstatement_reductions get_cumulated_reductions(void)
list summary_to_proper_reference(call, reference)
call.c
void error_reset_cumulated_reductions(void)
string reduction_operator_tag_name(tag)
returns a (static) string describing the tag t reduction
void init_printed_reductions(void)
void store_proper_reductions(statement, reductions)
bool old_reductions(string)
stub.c
bool same_reduction_p(reduction, reduction)
void close_printed_reductions(void)
bool print_code_proper_reductions(const char *)
Handlers for PIPSMAKE.
list reductions_get_omp_pragma_expr(loop, statement, bool)
pragma.c
bool proper_reductions(const char *)
handler for pipsmake input: module name output: TRUE side effects: some
string reduction_name(reduction)
returns the name of the reduction (!!! not allocated)
bool print_code_cumulated_reductions(const char *)
bool update_reduction_under_effect(reduction, effect)
bool update_compatible_reduction_with(reduction *, entity, reduction)
update *pr according to r for variable var r is not touched.
bool omp_pragma_expr_for_reduction(loop, statement, bool)
generate pragma for a reduction as a list of expressions
void set_proper_reductions(pstatement_reductions)
bool summary_reductions(const char *)
handler for pipsmake input: module name output: TRUE side effects: stores the summary reductions to p...
list translate_reductions(call)
of reduction
reductions delete_cumulated_reductions(statement)
expression get_complement_expression(statement, reference)
Return the "other part" of the reduction.
void store_cumulated_reductions(statement, reductions)
The structure used to build lists in NewGen.
1.9.1