reductions.h File Reference

#include "reductions_private.h"

Include dependency graph for reductions.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	reduction_variable(r)   reference_variable(reduction_reference(r))
	Warning! Do not modify this file that is automatically generated! More...
#define	reduction_none_p(r)   reduction_operator_none_p(reduction_op(r))
#define	reduction_tag(r)   reduction_operator_tag(reduction_op(r))
#define	make_none_reduction(var)
#define	DEBUG_REDUCTION(level, msg, red)    ifdebug(level){pips_debug(level, msg); print_reduction(red);}
	quick debug macros More...
#define	DEBUG_REDUCTIONS(level, msg, reds)

Functions
bool	replace_reduction_with_atomic (string)
	end of it More...
bool	flag_parallel_reduced_loops_with_atomic (string)
	Flag loop as parallel when replacement with atomic is possible without doing the replacement. More...
bool	flag_parallel_reduced_loops_with_openmp_directives (const char *)
	Flag loop as parallel with OpenMP directives taking reductions into account. More...
bool	old_reductions (string)
	stub.c More...
reductions	load_summary_reductions (entity)
	reductions.c More...
bool	summary_reductions (const char *)
	handler for pipsmake input: module name output: TRUE side effects: stores the summary reductions to pipsdbm More...
bool	proper_reductions_undefined_p (void)
void	reset_proper_reductions (void)
void	error_reset_proper_reductions (void)
void	set_proper_reductions (pstatement_reductions)
pstatement_reductions	get_proper_reductions (void)
void	init_proper_reductions (void)
void	close_proper_reductions (void)
void	store_proper_reductions (statement, reductions)
void	update_proper_reductions (statement, reductions)
reductions	load_proper_reductions (statement)
reductions	delete_proper_reductions (statement)
bool	bound_proper_reductions_p (statement)
void	store_or_update_proper_reductions (statement, reductions)
bool	proper_reductions (const char *)
	handler for pipsmake input: module name output: TRUE side effects: some More...
bool	cumulated_reductions_undefined_p (void)
void	reset_cumulated_reductions (void)
void	error_reset_cumulated_reductions (void)
void	set_cumulated_reductions (pstatement_reductions)
pstatement_reductions	get_cumulated_reductions (void)
void	init_cumulated_reductions (void)
void	close_cumulated_reductions (void)
void	store_cumulated_reductions (statement, reductions)
void	update_cumulated_reductions (statement, reductions)
reductions	load_cumulated_reductions (statement)
reductions	delete_cumulated_reductions (statement)
bool	bound_cumulated_reductions_p (statement)
void	store_or_update_cumulated_reductions (statement, reductions)
bool	cumulated_reductions (const char *)
	handler for pipsmake input: the module name output: TRUE side effects: some More...
entity	reduction_operator_entity (reduction_operator)
	match a reduction operator against operator entity More...
bool	same_reduction_p (reduction, reduction)
bool	reduction_star_p (reduction)
	utils.c More...
void	remove_variable_from_reduction (reduction, entity)
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. More...
bool	update_compatible_reduction (reduction *, entity, list, reductions)
	what to do with reduction *pr for variable var under effects le and reductions reds. More...
bool	pure_function_p (entity)
	extract the proper reduction of a call (instruction) if any. More...
bool	no_other_effects_on_references (statement, list)
	checks that the references are the only touched within this statement. More...
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... More...
expression	get_complement_expression (statement, reference)
	Return the "other part" of the reduction. More...
bool	loop_reductions (string)
	transformation.c More...
list	reductions_get_omp_pragma_expr (loop, statement, bool)
	pragma.c More...
string	reductions_get_omp_pragma_str (loop, statement)
bool	omp_pragma_expr_for_reduction (loop, statement, bool)
	generate pragma for a reduction as a list of expressions More...
bool	omp_pragma_expr_for (loop, statement)
	generate "pragma omp for" as a list of expressions More...
bool	printed_reductions_undefined_p (void)
	prettyprint.c More...
void	reset_printed_reductions (void)
void	error_reset_printed_reductions (void)
void	set_printed_reductions (pstatement_reductions)
pstatement_reductions	get_printed_reductions (void)
void	init_printed_reductions (void)
void	close_printed_reductions (void)
void	store_printed_reductions (statement, reductions)
void	update_printed_reductions (statement, reductions)
reductions	load_printed_reductions (statement)
reductions	delete_printed_reductions (statement)
bool	bound_printed_reductions_p (statement)
void	store_or_update_printed_reductions (statement, reductions)
string	note_for_statement (statement)
	generates a short note to tell about the type of the statement being decorated. More...
string	reduction_operator_tag_name (tag)
	returns a (static) string describing the tag t reduction More...
string	reduction_operator_name (reduction_operator)
	allocates and returns the name of the operator More...
string	reduction_name (reduction)
	returns the name of the reduction (!!! not allocated) More...
void	print_reduction (reduction)
bool	print_code_proper_reductions (const char *)
	Handlers for PIPSMAKE. More...
bool	print_code_cumulated_reductions (const char *)
list	summary_to_proper_reference (call, reference)
	call.c More...
list	translate_reductions (call)
	of reduction More...
bool	reduction_propagation (const char *)
	propagation.c More...
bool	reduction_detection (const char *)

Macro Definition Documentation

DEBUG_REDUCTION

#define DEBUG_REDUCTION	(		level,
			msg,
			red
	)		ifdebug(level){pips_debug(level, msg); print_reduction(red);}

quick debug macros

Definition at line 45 of file reductions.h.

DEBUG_REDUCTIONS

#define DEBUG_REDUCTIONS	(		level,
			msg,
			reds
	)

Value:

  ifdebug(level){pips_debug(level, msg); \
                 gen_map(print_reduction, reductions_list(reds));}

Definition at line 47 of file reductions.h.

make_none_reduction

#define make_none_reduction

(

var

)

Value:

    make_reduction(make_reference(var, NIL), \
                   make_reduction_operator(is_reduction_operator_none, UU),\
                   NIL, NIL)

Definition at line 38 of file reductions.h.

reduction_none_p

#define reduction_none_p

(

r

)

reduction_operator_none_p(reduction_op(r))

Definition at line 36 of file reductions.h.

reduction_tag

#define reduction_tag

(

r

)

reduction_operator_tag(reduction_op(r))

Definition at line 37 of file reductions.h.

reduction_variable

#define reduction_variable

(

r

)

reference_variable(reduction_reference(r))

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/reductions/reductions-local.h instead, to add your own modifications. header file built by cproto reductions-local.h shorthands for REDUCTION:

Definition at line 35 of file reductions.h.

Function Documentation

bound_cumulated_reductions_p()

bool bound_cumulated_reductions_p

(

statement

)

Referenced by build_reduction_of_variable(), and list_of_reduced_variables().

Here is the caller graph for this function:

bound_printed_reductions_p()

bool bound_printed_reductions_p

(

statement

)

Referenced by statement_is_reduction(), and text_reductions().

Here is the caller graph for this function:

bound_proper_reductions_p()

bool bound_proper_reductions_p

(

statement

)

call_proper_reduction_p()

bool call_proper_reduction_p	(	statement	s,
		call	c,
		reduction *	red
	)

This function look for a reduction and return it if found mallocs are avoided if nothing is found...

looks for v = v OP y or v OP= y, where y is independent of v.

Returns

true if the call in s a reduction

Parameters

s

Parameters

c	needed to query about proper effects
red	the call of interest

Definition at line 633 of file utils.c.

{
  tag op; // The operator tag (sum, mul ...)
  list le = NIL; // list of expression
  list lr = NIL; // list of reference
  list lp = NIL; // list of Preference
  bool comm      = false; // The commutatity operator flag
  bool assign_op = false; // The assign operator flag
  bool update_op = false; // The reduction update operator flag;
  bool unary_op  = false; // The reduction unary update operator flag;
  entity fct = call_function(c); // the call function to test for reduction
  reference  lhs   = reference_undefined;
  reference  other = reference_undefined;
  expression elhs  = expression_undefined;
  expression erhs  = expression_undefined;
 
  pips_debug(7, "call to %s (%p)\n", entity_name(call_function(c)), s);
 
  // First init the operation flags
  // only check the operator type if the previous test failed
  if ((assign_op = ENTITY_ASSIGN_P (fct)) == false)
    if ((update_op=extract_reduction_update_operator(fct, &op, &comm))==false)
      unary_op = extract_reduction_unary_update_operator (fct, &op);
 
  // if no suitable operator has been found : return false
  if ((unary_op == false) && (update_op == false) && (assign_op == false)) {
    pips_debug(5,"No unary, nor update, no assign !\n");
    return false;
  }
 
  // get the left and right operands
  le = call_arguments(c);
  elhs = EXPRESSION(CAR(le));
  //no right operand for unary operator
  if (unary_op == false) erhs = EXPRESSION(CAR(CDR(le)));
  if (syntax_reference_p(expression_syntax(elhs)) == false) {
    pips_user_warning ("The left hand side of assignment is not a reference, "
        "this is not handled and no reduction will be detected\n");
    return false;
  }
  lhs = syntax_reference(expression_syntax(elhs));
 
  // the lhs and rhs (if exits) must be functionnal
  // (same location on different evaluations)
  if (!functional_object_p((gen_chunk *) lhs)   ||
      ((unary_op == false) && !functional_object_p((gen_chunk *) erhs))) {
    pips_debug(5,"Lhs or Rhs not functional !\n");
    return false;
  }
  pips_debug(8, "lhs and rhs are functional\n");
 
  // Check that the operation performed is valid for a reduction,
  // The check is useless for reduction update and unary operator because
  // already done previously by "extract_reduction_update_operator" and
  // "extract_reduction_unary_update_operator"
  if ((unary_op == false) && (update_op == false) &&
      (extract_reduction_operator(erhs, &op, &comm) == false)) {
    pips_debug(5,"extract_reduction_operator returned false !!\n");
    return false;
  }
  pips_debug(8, "reduction operator %s\n", reduction_operator_tag_name(op));
 
  // there should be another direct reference to lhs if not unary
  // !!! syntax is a call if extract_reduction_operator returned TRUE
  if (unary_op == false) {
    if (!equal_reference_in_expression_p(lhs, erhs, op, update_op, &other)) {
      pips_debug(5,"!equal_reference_in_expression_p !!\n");
      return false;
    }
    pips_debug(8, "matching reference found (%p)\n", other);
  }
 
  // build the list of found reference to the reduced variable
  if ((update_op == true) || (unary_op == true))
    lr = CONS(REFERENCE, lhs, NIL);
  else
    lr = CONS(REFERENCE, lhs, CONS(REFERENCE, other, NIL));
  pips_debug(7,"list lr is: %p and %p\n", other, lhs);
  // there should be no extra effects on the reduced variable
  if (!no_other_effects_on_references (s, lr)) {
    pips_debug(5,"Other effects on references !!\n");
    gen_free_list(lr);
    return false;
  }
  pips_debug(8, "no other effects\n");
 
  FOREACH (REFERENCE, r, lr) {
    lp = CONS(PREFERENCE, make_preference(r), lp);
  }
  gen_free_list(lr), lr = NIL;
 
  // well, it is ok for a reduction now!
  *red = make_reduction(copy_reference(lhs),
                        make_reduction_operator(op, UU),
                        referenced_variables(lhs),
                        lp);
 
  DEBUG_REDUCTION(7, "returning\n", *red);
  return true;
}

References call_arguments, call_function, CAR, CDR, CONS, copy_reference(), DEBUG_REDUCTION, ENTITY_ASSIGN_P, entity_name, equal_reference_in_expression_p(), EXPRESSION, expression_syntax, expression_undefined, extract_reduction_operator(), extract_reduction_unary_update_operator(), extract_reduction_update_operator(), FOREACH, functional_object_p(), gen_free_list(), make_preference(), make_reduction(), make_reduction_operator(), NIL, no_other_effects_on_references(), pips_debug, pips_user_warning, PREFERENCE, reduction_operator_tag_name(), REFERENCE, reference_undefined, referenced_variables(), syntax_reference, syntax_reference_p, update_op(), and UU.

Referenced by pr_call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

close_cumulated_reductions()

void close_cumulated_reductions

(

void

)

close_printed_reductions()

void close_printed_reductions

(

void

)

close_proper_reductions()

void close_proper_reductions

(

void

)

cumulated_reductions()

bool cumulated_reductions

(

const char *

module_name

)

handler for pipsmake input: the module name output: TRUE side effects: some

• requires CODE, PROPER_{EFFECTS,REDUCTIONS} and CUMULATED_EFFECTS
• returns CUMULATED_REDUCTIONS to pips dbm

gets what is needed from PIPS DBM

do the job here

returns the result to the DBM...

Parameters

module_name

odule_name

Definition at line 529 of file reductions.c.

{
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s\n", module_name);
 
    init_cumulated_reductions();
    set_generic_effects_as_needed();
 
    /* gets what is needed from PIPS DBM
     */
    set_current_module_entity(local_name_to_top_level_entity(module_name));
    set_current_module_statement((statement)
        db_get_memory_resource(DBR_CODE, module_name, true));
    set_proper_references((statement_effects)
        db_get_memory_resource(DBR_PROPER_REFERENCES, module_name, true));
    set_rw_effects((statement_effects)
        db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
    set_proper_reductions((pstatement_reductions)
        db_get_memory_resource(DBR_PROPER_REDUCTIONS, module_name, true));
 
    /* do the job here
     */
    gen_recurse(get_current_module_statement(),instruction_domain,gen_true,compute_cumulated_reductions);
 
    /* returns the result to the DBM...
     */
    DB_PUT_MEMORY_RESOURCE
        (DBR_CUMULATED_REDUCTIONS, module_name, get_cumulated_reductions());
 
    reset_cumulated_reductions();
    reset_proper_reductions();
    reset_proper_references();
    reset_rw_effects();
    reset_current_module_entity();
    reset_current_module_statement();
    generic_effects_reset_all_methods();
 
    debug_off();
    return true;
}

References compute_cumulated_reductions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), generic_effects_reset_all_methods(), get_cumulated_reductions(), get_current_module_statement(), init_cumulated_reductions(), instruction_domain, local_name_to_top_level_entity(), module_name(), pips_debug, reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_reductions(), reset_proper_references(), reset_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_generic_effects_as_needed(), set_proper_reductions(), set_proper_references(), and set_rw_effects().

Here is the call graph for this function:

cumulated_reductions_undefined_p()

bool cumulated_reductions_undefined_p

(

void

)

delete_cumulated_reductions()

reductions delete_cumulated_reductions

(

statement

)

delete_printed_reductions()

reductions delete_printed_reductions

(

statement

)

delete_proper_reductions()

reductions delete_proper_reductions

(

statement

)

error_reset_cumulated_reductions()

void error_reset_cumulated_reductions

(

void

)

error_reset_printed_reductions()

void error_reset_printed_reductions

(

void

)

error_reset_proper_reductions()

void error_reset_proper_reductions

(

void

)

flag_parallel_reduced_loops_with_atomic()

bool flag_parallel_reduced_loops_with_atomic

(

string

mod_name

)

Flag loop as parallel when replacement with atomic is possible without doing the replacement.

Parameters

mod_name

od_name

Definition at line 411 of file atomic.c.

                                                               {
  debug_on("FLAG_PARALLEL_REDUCED_LOOPS_WITH_ATOMIC_DEBUG_LEVEL");
 
  bool result = process_reduced_loops(mod_name, DO_NOT_REPLACE);
 
  debug_off();
 
  return result;
 
}

References debug_off, debug_on, DO_NOT_REPLACE, and process_reduced_loops().

Here is the call graph for this function:

flag_parallel_reduced_loops_with_openmp_directives()

bool flag_parallel_reduced_loops_with_openmp_directives

(

const char *

mod_name

)

Flag loop as parallel with OpenMP directives taking reductions into account.

Parameters

mod_name

od_name

Definition at line 426 of file atomic.c.

                                                                               {
  debug_on("FLAG_PARALLEL_REDUCED_LOOPS_WITH_ATOMIC_DEBUG_LEVEL");
 
  bool result = process_reduced_loops(mod_name, USE_OPENMP);
 
  debug_off();
 
  return result;
 
}

get_complement_expression()

expression get_complement_expression	(	statement	s,
		reference	reduced
	)

Return the "other part" of the reduction.

If the statement is : sum = sum + a[i]; then we'll return a[i]

try to find out which of the two expression corresponds to the reduced reference. We'll return the other...

Parameters

reduced

educed

Definition at line 743 of file utils.c.

                                                                     {
  expression complement = expression_undefined;
  // We handle only trivial cases
  if(statement_call_p(s)) {
    call c = statement_call(s);
    entity fct = call_function(c);
    list le = call_arguments(c);
    tag op;
    bool comm = false; // Commutativity
    // Differentiate unary && update && binary operators
    if (ENTITY_ASSIGN_P (fct)){
      // Normal case, binary expected
      expression rhs = EXPRESSION(CAR(CDR(le)));
      if(expression_call_p(rhs)) {
        list args = call_arguments(expression_call(rhs));
        pips_assert("Have a binary operator\n", gen_length(args)==2);
        /* try to find out which of the two expression corresponds to the
         * reduced reference. We'll return the other...
         */
        expression e1 = EXPRESSION(CAR(args));
        expression e2 = EXPRESSION(CAR(CDR(args)));
        if(expression_reference_p(e1) &&
            same_ref_name_p(reduced,expression_reference(e1))) {
          complement = e2;
        } else if(expression_reference_p(e2) &&
            same_ref_name_p(reduced,expression_reference(e2))) {
          complement = e2;
        } else {
          pips_user_warning("Atomic operation replacement seems less general"
              " than reduction detection. This merits a bug report !\n");
        }
      } else {
        pips_user_warning("Atomic operation replacement seems less general than"
            " reduction detection. This merits a bug report !\n");
      }
    } else if(extract_reduction_unary_update_operator(fct, &op)) {
      // ++ or --  : we return 1
      pips_debug(3,"We have an unary operator\n");
      complement = int_to_expression(1);
    } else if(extract_reduction_update_operator(fct, &op, &comm)) {
      // += or similar, return directly rhs
      pips_debug(3,"We have an update operator\n");
      complement = EXPRESSION(CAR(CDR(le)));
    } else {
      pips_internal_error("We have a reduction, but the statement is neither an"
          " unary nor a binary ? It's a bug, sorry no choice but abort !\n");
    }
  }
  return complement;
}

References call_arguments, call_function, CAR, CDR, ENTITY_ASSIGN_P, EXPRESSION, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), expression_undefined, extract_reduction_unary_update_operator(), extract_reduction_update_operator(), gen_length(), int_to_expression(), pips_assert, pips_debug, pips_internal_error, pips_user_warning, same_ref_name_p(), statement_call(), and statement_call_p().

Referenced by replace_reductions_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cumulated_reductions()

pstatement_reductions get_cumulated_reductions

(

void

)

Referenced by cumulated_reductions().

Here is the caller graph for this function:

get_printed_reductions()

pstatement_reductions get_printed_reductions

(

void

)

get_proper_reductions()

pstatement_reductions get_proper_reductions

(

void

)

Referenced by proper_reductions().

Here is the caller graph for this function:

init_cumulated_reductions()

void init_cumulated_reductions

(

void

)

Referenced by cumulated_reductions().

Here is the caller graph for this function:

init_printed_reductions()

void init_printed_reductions

(

void

)

init_proper_reductions()

void init_proper_reductions

(

void

)

Referenced by proper_reductions().

Here is the caller graph for this function:

load_cumulated_reductions()

reductions load_cumulated_reductions

(

statement

)

Referenced by build_reduction_of_variable(), compute_summary_reductions(), do_expression_reduction(), do_reduction_atomization(), list_of_reduced_variables(), and reductions_rewrite().

Here is the caller graph for this function:

load_printed_reductions()

reductions load_printed_reductions

(

statement

)

Referenced by reductions_get_omp_pragma_expr(), reductions_get_omp_pragma_str(), statement_is_reduction(), and text_reductions().

Here is the caller graph for this function:

load_proper_reductions()

reductions load_proper_reductions

(

statement

)

Referenced by build_reduction_of_variable(), check_proper_reductions(), compute_cumulated_reductions(), do_reduction_propagation(), list_of_reduced_variables(), and pr_call_flt().

Here is the caller graph for this function:

load_summary_reductions()

reductions load_summary_reductions

(

entity

f

)

reductions.c

reductions.c

thus summary reductions can be propagated with no harm... just the usual conditions must be checked (no other effect on the variable)

Definition at line 55 of file reductions.c.

{
    pips_assert("is a module", entity_module_p(f));
    return (reductions) db_get_memory_resource
        (DBR_SUMMARY_REDUCTIONS, module_local_name(f), true);
}

References db_get_memory_resource(), entity_module_p(), f(), module_local_name(), and pips_assert.

Referenced by translate_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_reductions()

bool loop_reductions

(

string

module

)

transformation.c

Parameters

module

odule

Definition at line 35 of file transformation.c.

{
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s\n", module);
 
    pips_assert ("not implemented yet\n", false);
 
    debug_off();
    return true;
}

References debug_off, debug_on, module, pips_assert, and pips_debug.

no_other_effects_on_references()

bool no_other_effects_on_references	(	statement	s,
		list	lr
	)

checks that the references are the only touched within this statement.

I trust the proper effects to store all references...

of effect

Parameters

lr	of reference on the same variable

Definition at line 596 of file utils.c.

{
    list /* of effect */ le;
    entity var;
    if (ENDP(lr)) return true;
 
    le = effects_effects(load_proper_references(s));
    var = reference_variable(REFERENCE(CAR(lr)));
 
    pips_debug(7,"entity name: %s\n", entity_name(var));
 
    FOREACH (EFFECT, e, le) {
      if(!store_effect_p(e)) continue;
      reference r = effect_any_reference(e);
      if (!gen_in_list_p(r, lr) && store_effect_p(e) &&
          entities_may_conflict_p(reference_variable(r), var)) {
        pips_debug(7,"Effect may touch variable : ");print_effect(e);
        return false;
      }
      pips_debug(7,"refrence r: %p of entity: %s\n", r, entity_name (reference_variable(r)));
    }
 
    return true;
}

References CAR, EFFECT, effect_any_reference, effects_effects, ENDP, entities_may_conflict_p(), entity_name, FOREACH, gen_in_list_p(), load_proper_references(), pips_debug, print_effect, REFERENCE, reference_variable, and store_effect_p().

Referenced by call_proper_reduction_p().

Here is the call graph for this function:

Here is the caller graph for this function:

note_for_statement()

string note_for_statement

(

statement

s

)

generates a short note to tell about the type of the statement being decorated.

Definition at line 55 of file prettyprint.c.

{
    instruction i = statement_instruction(s);
    switch (instruction_tag(i))
    {
    case is_instruction_sequence: return "seq  ";
    case is_instruction_loop: return "loop ";
    case is_instruction_test: return "test ";
    case is_instruction_call: return "call ";
    case is_instruction_unstructured: return "unst ";
    case is_instruction_whileloop: return "while ";
    case is_instruction_goto: return "goto ";
    case is_instruction_forloop: return "for ";
    case is_instruction_expression: return "expr ";
    default: 
      pips_internal_error("unexpected instruction tag");
      break;
    }
    return "";
}

References instruction_tag, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, pips_internal_error, and statement_instruction.

Referenced by build_creductions_of_statement(), build_reduction_of_variable(), compute_cumulated_reductions(), list_of_reduced_variables(), and text_reductions().

Here is the caller graph for this function:

old_reductions()

bool old_reductions

(

string

mod_name

)

stub.c

true or FALSE? After all, it's just a user warning, not an error

Parameters

mod_name

od_name

Definition at line 63 of file stub.c.

{
    string program_name = db_get_current_workspace_name() ;
    char *command ;
    struct stat buf ;
    char *options ; 
    statement mod_stat ;
 
    if( stat( LISP, &buf ) != 0 ) {
        user_warning("reductions",
                     "No lisp! Skipping reduction detection\n") ;
        /* true or FALSE? After all, it's just a user warning, not an error */
        return false;
    }
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    db_close_workspace(false) ;
    options = (get_debug_level() <= 5) ? " -batch" : "" ;
    asprintf(&command, 
            "(echo \"(defparameter files-directory \\\"%s\\\")\
             (load (concatenate %s files-directory \\\"/init\\\"))\
             (load (concatenate %s files-directory \\\"/top\\\"))\
             (reductions t \\\"%s\\\" \\\"%s\\\")\") | %s%s", 
            REDUCTIONS_SOURCE_DIRECTORY,
            "'string",
            "'string",
            program_name, 
            mod_name, 
            LISP,
            options ) ;
    debug( 5, "reductions", "\ncommand = %s\n", command ) ;
 
    if( (system( command ) >> 8) != 0 ) {
        pips_internal_error("Lisp process died unexpectedly" ) ;
    }
    free(command);
    debug_off();
    db_open_workspace( program_name ) ;
    mod_stat = (statement) 
            db_get_memory_resource(DBR_CODE, mod_name, true);
    module_reorder( mod_stat ) ;
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(mod_name), mod_stat);
 
    return true;
}

References asprintf, buf, db_close_workspace(), db_get_current_workspace_name(), db_get_memory_resource(), db_open_workspace(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, free(), get_debug_level(), LISP, mod_stat, module_reorder(), pips_internal_error, REDUCTIONS_SOURCE_DIRECTORY, strdup(), and user_warning.

Here is the call graph for this function:

omp_pragma_expr_for()

bool omp_pragma_expr_for	(	loop	l,
		statement	stmt
	)

generate "pragma omp for" as a list of expressions

Returns

true if a pragma has been generated

Parameters

l,the	loop to analyze for omp for
stmt,the	statament where the pragma should be attached

Parameters

stmt

tmt

Definition at line 366 of file pragma.c.

                                                  {
  list exprs = NULL;
  if (execution_parallel_p(loop_execution(l))) {
    // the list of expression to generate initialized with
    // pragma "omp parallel for"
    list exprs = pragma_omp_parallel_for_as_exprs ();
    exprs = omp_append_private_clause (l, exprs);
    // insert the pragma as an expression to the current statement
    add_pragma_expr_to_statement (stmt, exprs);
    pips_debug (5, "new for pragma as an extension added\n");
  }
  return (exprs != NULL);
}

References add_pragma_expr_to_statement(), execution_parallel_p, loop_execution, omp_append_private_clause(), pips_debug, and pragma_omp_parallel_for_as_exprs().

Referenced by process_reductions_in_openmp_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_pragma_expr_for_reduction()

bool omp_pragma_expr_for_reduction	(	loop	l,
		statement	stmt,
		bool	strict
	)

generate pragma for a reduction as a list of expressions

Returns

true if a pragma has been generated

Parameters

l,the	loop to analyze for omp reduction
stmt,the	statament where the pragma should be attached
strict,if	set to true, only one-liner statements with reductions are handled

Parameters

stmt	tmt
strict	trict

Definition at line 346 of file pragma.c.

                                                                         {
  // the list of expression to generate
  list exprs = NULL;
  exprs = reductions_get_omp_pragma_expr(l, stmt, strict);
  // insert the pragma (if any) as an expression to the current statement
  if (exprs != NULL) {
    // remove any previous openmp expression to make sure we do not introduce inconsistency
    statement_remove_omp_clauses(stmt);
    // check if a private clause is needed on top of the reduction clause
    exprs = omp_append_private_clause (l, exprs);
    add_pragma_expr_to_statement (stmt, exprs);
    pips_debug (5, "new reduction pragma as an extension added\n");
  }
  return (exprs != NULL);
}

References add_pragma_expr_to_statement(), omp_append_private_clause(), pips_debug, reductions_get_omp_pragma_expr(), and statement_remove_omp_clauses().

Referenced by process_reductions_in_openmp_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

print_code_cumulated_reductions()

bool print_code_cumulated_reductions

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 258 of file prettyprint.c.

{
    return print_any_reductions(module_name,
                                DBR_CUMULATED_REDUCTIONS,
                                CUMU_DECO,
                                DBR_SUMMARY_REDUCTIONS,
                                CUMU_SUFFIX);
}

References CUMU_DECO, CUMU_SUFFIX, module_name(), and print_any_reductions().

Here is the call graph for this function:

print_code_proper_reductions()

bool print_code_proper_reductions

(

const char *

module_name

)

Handlers for PIPSMAKE.

Parameters

module_name

odule_name

Definition at line 249 of file prettyprint.c.

{
    return print_any_reductions(module_name,
                                DBR_PROPER_REDUCTIONS,
                                PROP_DECO,
                                NULL,
                                PROP_SUFFIX);
}

References module_name(), print_any_reductions(), PROP_DECO, and PROP_SUFFIX.

Here is the call graph for this function:

print_reduction()

void print_reduction

(

reduction

r

)

Definition at line 137 of file prettyprint.c.

{
    reference ref = reduction_reference(r);
    fprintf(stderr, "reduction is %s[",
            reduction_operator_tag_name
                (reduction_operator_tag(reduction_op(r))));
    if (!reference_undefined_p(ref)) print_reference(ref);
    fprintf(stderr, "]\n");
}

References fprintf(), print_reference(), reduction_op, reduction_operator_tag, reduction_operator_tag_name(), reduction_reference, ref, and reference_undefined_p.

Referenced by replace_reductions_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

printed_reductions_undefined_p()

bool printed_reductions_undefined_p

(

void

)

prettyprint.c

proper_reductions()

bool proper_reductions

(

const char *

module_name

)

handler for pipsmake input: module name output: TRUE side effects: some

• requires CODE PROPER_EFFECTS and callees' SUMMARY_{EFFECTS,REDUCTIONS}
• returns PROPER_REDUCTIONS to pips dbm

gets what is needed from PIPS DBM

do the job

returns the result to the DBM...

Parameters

module_name

odule_name

Definition at line 359 of file reductions.c.

{
    entity module;
 
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s\n", module_name);
 
    init_proper_reductions();
    set_generic_effects_as_needed();
 
    /* gets what is needed from PIPS DBM
     */
    module = local_name_to_top_level_entity(module_name);
    set_current_module_entity(module);
    set_current_module_statement
        ((statement) db_get_memory_resource(DBR_CODE, module_name, true));
    set_proper_references((statement_effects)
        db_get_memory_resource(DBR_PROPER_REFERENCES, module_name, true));
 
    /* do the job
     */
    compute_proper_reductions(get_current_module_statement());
 
    /* returns the result to the DBM...
     */
    DB_PUT_MEMORY_RESOURCE
        (DBR_PROPER_REDUCTIONS, module_name, get_proper_reductions());
 
    reset_proper_reductions();
    reset_proper_references();
    reset_current_module_entity();
    reset_current_module_statement();
    generic_effects_reset_all_methods();
 
    debug_off();
    return true;
}

References compute_proper_reductions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, generic_effects_reset_all_methods(), get_current_module_statement(), get_proper_reductions(), init_proper_reductions(), local_name_to_top_level_entity(), module, module_name(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_proper_reductions(), reset_proper_references(), set_current_module_entity(), set_current_module_statement(), set_generic_effects_as_needed(), and set_proper_references().

Here is the call graph for this function:

proper_reductions_undefined_p()

bool proper_reductions_undefined_p

(

void

)

pure_function_p()

bool pure_function_p

(

entity

f

)

extract the proper reduction of a call (instruction) if any.

I trust intrinsics (operations?) and summary effects...

else

a side effect!?

LUNS

Definition at line 343 of file utils.c.

{
    value v = entity_initial(f);
 
    if (value_symbolic_p(v) || value_constant_p(v) || value_intrinsic_p(v))
      return true;
    /* else */
 
    if (entity_module_p(f))
    {
      FOREACH (EFFECT, e, load_summary_effects(f)) {
        if(!store_effect_p(e)) continue;
        if (effect_write_p(e)) /* a side effect!? */
          return false;
        if (io_effect_entity_p(effect_variable(e))) /* LUNS */
          return false;
      }
    }
 
    return true;
}

References EFFECT, effect_variable, effect_write_p, entity_initial, entity_module_p(), f(), FOREACH, io_effect_entity_p(), load_summary_effects(), store_effect_p(), value_constant_p, value_intrinsic_p, and value_symbolic_p.

Referenced by call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_detection()

bool reduction_detection

(

const char *

mod_name

)

get the resources

do the job

validate computation

update/release resources

Parameters

mod_name

od_name

Definition at line 245 of file propagation.c.

                                                {
    /* get the resources */
    statement mod_stmt = (statement)
        db_get_memory_resource(DBR_CODE, mod_name, true);
 
    set_current_module_statement(mod_stmt); 
    set_current_module_entity(module_name_to_entity(mod_name));
        set_ordering_to_statement(mod_stmt);
    graph dependence_graph = 
        (graph) db_get_memory_resource(DBR_DG, mod_name, true);
 
    /* do the job */
    debug_on("REDUCTION_DETECTION_DEBUG_LEVEL");
    bool res = do_reduction_detection(dependence_graph);
    debug_off();
    if(res) {
        /* validate computation */
        module_reorder(mod_stmt);
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
    }
 
    /* update/release resources */
        reset_ordering_to_statement();
    reset_current_module_statement();
    reset_current_module_entity();
    return res;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dependence_graph, do_reduction_detection(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), set_current_module_entity(), set_current_module_statement(), and set_ordering_to_statement().

Here is the call graph for this function:

reduction_name()

string reduction_name

(

reduction

r

)

returns the name of the reduction (!!! not allocated)

Definition at line 110 of file prettyprint.c.

{
    return reduction_operator_tag_name(reduction_tag(r));
}

References reduction_operator_tag_name(), and reduction_tag.

Here is the call graph for this function:

reduction_operator_entity()

entity reduction_operator_entity

(

reduction_operator

op

)

match a reduction operator against operator entity

Parameters

op	reduction operator

Returns

entity representing corresponding operator

Parameters

op

p

Definition at line 577 of file reductions.c.

{
    string opname = string_undefined;
    switch( reduction_operator_tag(op) ) {
        case is_reduction_operator_sum:
            opname=PLUS_OPERATOR_NAME;break;
        case is_reduction_operator_and:
            opname=AND_OPERATOR_NAME;break;
        case is_reduction_operator_bitwise_and:
            opname=BITWISE_AND_OPERATOR_NAME;break;
        case is_reduction_operator_bitwise_or:
            opname=BITWISE_OR_OPERATOR_NAME;break;
        case is_reduction_operator_bitwise_xor:
            opname=BITWISE_XOR_OPERATOR_NAME;break;
        case is_reduction_operator_csum:
            opname=PLUS_C_OPERATOR_NAME;break;
        case is_reduction_operator_eqv:
            opname=EQUIV_OPERATOR_NAME;break;
        case is_reduction_operator_max:
            opname=MAX_OPERATOR_NAME;break;
        case is_reduction_operator_min:
            opname=MIN_OPERATOR_NAME;break;
        case is_reduction_operator_neqv:
            opname=NON_EQUIV_OPERATOR_NAME;break;
        case is_reduction_operator_or:
            opname=OR_OPERATOR_NAME;break;
        case is_reduction_operator_prod:
            opname=MULTIPLY_OPERATOR_NAME;break;
        default:
            pips_internal_error("unhandled case");
    }
    return entity_intrinsic(opname);
}

References AND_OPERATOR_NAME, BITWISE_AND_OPERATOR_NAME, BITWISE_OR_OPERATOR_NAME, BITWISE_XOR_OPERATOR_NAME, entity_intrinsic(), EQUIV_OPERATOR_NAME, is_reduction_operator_and, is_reduction_operator_bitwise_and, is_reduction_operator_bitwise_or, is_reduction_operator_bitwise_xor, is_reduction_operator_csum, is_reduction_operator_eqv, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_neqv, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, MAX_OPERATOR_NAME, MIN_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, NON_EQUIV_OPERATOR_NAME, opname(), OR_OPERATOR_NAME, pips_internal_error, PLUS_C_OPERATOR_NAME, PLUS_OPERATOR_NAME, reduction_operator_tag, and string_undefined.

Referenced by do_expression_reduction(), do_reduction_atomization(), and do_reduction_propagation().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_operator_name()

string reduction_operator_name

(

reduction_operator

o

)

allocates and returns the name of the operator

Definition at line 103 of file prettyprint.c.

{
    return strdup(reduction_operator_tag_name(reduction_operator_tag(o)));
}

References reduction_operator_tag, reduction_operator_tag_name(), and strdup().

Referenced by words_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_operator_tag_name()

string reduction_operator_tag_name

(

tag

t

)

returns a (static) string describing the tag t reduction

Definition at line 78 of file prettyprint.c.

{
    switch(t)
    {
    case is_reduction_operator_none:        return "none";
    case is_reduction_operator_sum:         return "sum";
    case is_reduction_operator_csum:        return "csum";
    case is_reduction_operator_prod:        return "prod";
    case is_reduction_operator_min:         return "min";
    case is_reduction_operator_max:         return "max";
    case is_reduction_operator_and:         return "and";
    case is_reduction_operator_or:          return "or";
    case is_reduction_operator_bitwise_or:  return "bitwise_or";
    case is_reduction_operator_bitwise_xor: return "bitwise_xor";
    case is_reduction_operator_bitwise_and: return "bitwise_and";
    case is_reduction_operator_eqv:         return "eqv";
    case is_reduction_operator_neqv:        return "neqv";
    default: pips_internal_error("unexpected reduction operator tag!");
    }
 
    return NULL;
}

References is_reduction_operator_and, is_reduction_operator_bitwise_and, is_reduction_operator_bitwise_or, is_reduction_operator_bitwise_xor, is_reduction_operator_csum, is_reduction_operator_eqv, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_neqv, is_reduction_operator_none, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, and pips_internal_error.

Referenced by call_proper_reduction_p(), print_reduction(), reduction_name(), reduction_operator_name(), remove_variable_from_reduction(), and update_reduction_under_effect().

Here is the caller graph for this function:

reduction_propagation()

bool reduction_propagation

(

const char *

mod_name

)

propagation.c

propagation.c

the pattern checked is a = b + c; r = r + a; which should become r = r +b ; r = r +c ;

get the resources

do the job

validate computation

update/release resources

Parameters

mod_name

od_name

Definition at line 125 of file propagation.c.

                                                  {
    /* get the resources */
    statement mod_stmt = (statement)
        db_get_memory_resource(DBR_CODE, mod_name, true);
 
    set_current_module_statement(mod_stmt); 
    set_proper_reductions((pstatement_reductions) db_get_memory_resource(DBR_PROPER_REDUCTIONS, mod_name, true));
    set_current_module_entity(module_name_to_entity(mod_name));
        set_ordering_to_statement(mod_stmt);
    graph dependence_graph = 
        (graph) db_get_memory_resource(DBR_DG, mod_name, true);
 
    simplify_c_operator(get_current_module_statement());
 
    /* do the job */
    do_reduction_propagation(dependence_graph);
 
    /* validate computation */
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
 
    /* update/release resources */
    reset_proper_reductions();
        reset_ordering_to_statement();
    reset_current_module_statement();
    reset_current_module_entity();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, dependence_graph, do_reduction_propagation(), get_current_module_statement(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_reductions(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_reductions(), and simplify_c_operator().

Here is the call graph for this function:

reduction_star_p()

bool reduction_star_p

(

reduction

r

)

utils.c

Definition at line 46 of file utils.c.

                                   {
    reference ref = reduction_reference(r);
    FOREACH(EXPRESSION,exp,reference_indices(ref))
        if( syntax_range_p(expression_syntax(exp)) ) {
            range ran = syntax_range(expression_syntax(exp));
            if(expression_undefined_p(range_upper(ran)))
                return true;
        }
    return false;
}

References exp, EXPRESSION, expression_syntax, expression_undefined_p, FOREACH, range_upper, reduction_reference, ref, reference_indices, syntax_range, and syntax_range_p.

Referenced by rename_statement_reductions().

Here is the caller graph for this function:

reductions_get_omp_pragma_expr()

list reductions_get_omp_pragma_expr	(	loop	l,
		statement	stmt,
		bool	strict
	)

pragma.c

Parameters

stmt	tmt
strict	trict

Definition at line 227 of file pragma.c.

                                                                          {
  list exprs = NIL;
  // check that reduction as been detected at loop level
  if  (statement_is_reduction (stmt) == true) {
    reductions rs = load_printed_reductions(stmt);
    // check that the reductions are done on scalars and not arrays
    if (reductions_on_scalar (rs) == true) {
      // reset the all reduction flag
      reset_all_reduction ();
      // check that all the statements of the loop are reductions otherwise, do
      // not generate omp reduction pragma
      // the test is too restrictive so need to be improved
      if(strict)
          gen_recurse(l, statement_domain, gen_true, compute_all_reduction);
      if (all_reduction) {
                                reductions rs = load_printed_reductions(stmt);
                                FOREACH (REDUCTION, red, reductions_list(rs)) {
                                  exprs = gen_expression_cons (reduction_as_expr (red), exprs);
                                }
                                //secondly get "omp parallel for" as an expr and concatenate
                                list parallel_for = pragma_omp_parallel_for_as_exprs ();
                                exprs = gen_nconc (exprs, parallel_for);
      }
    }
  }
  pips_debug(5, "finish with pragma\n");
  return exprs;
}

References all_reduction, compute_all_reduction(), FOREACH, gen_expression_cons(), gen_nconc(), gen_recurse, gen_true(), load_printed_reductions(), NIL, pips_debug, pragma_omp_parallel_for_as_exprs(), REDUCTION, reduction_as_expr(), reductions_list, reductions_on_scalar(), reset_all_reduction(), statement_domain, and statement_is_reduction().

Referenced by omp_pragma_expr_for_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

reductions_get_omp_pragma_str()

string reductions_get_omp_pragma_str	(	loop	l,
		statement	stmt
	)

Returns

a string with omp pragma for reductions

Parameters

l,the	loop associated with the statement
stmt,the	statement to analyzed for reductions, must be a loop

Parameters

stmt

tmt

Definition at line 259 of file pragma.c.

                                                              {
  string_buffer buf  = string_buffer_make (false);
  // check that reduction as been detected at loop level
  if  (statement_is_reduction (stmt) == true) {
    reductions rs = load_printed_reductions(stmt);
    // check that the reductions are done on scalars and not arrays
    if (reductions_on_scalar (rs) == true) {
      // reset the all reduction flag
      reset_all_reduction ();
      // check that all the statements of the loop are reductions otherwise, do
      // not generate omp reduction pragma
      // the test is too restrictive so need to be improved
      gen_recurse(l, statement_domain, gen_true, compute_all_reduction);
      if (all_reduction == true) {
        string header = (prettyprint_language_is_fortran_p ()
                         ? OMP_PRAGMA_FOR_HEADER_F :
                         OMP_PRAGMA_FOR_HEADER_C);
        string_buffer_append (buf, strdup (header));
        string_buffer_append (buf, strdup (" "));
        FOREACH (REDUCTION, red, reductions_list(rs)) {
          string_buffer_append (buf, reduction_as_str (red));
        }
      }
    }
  }
  string result = string_buffer_to_string (buf);
  pips_debug(5, "finish with pragma: %s\n", result);
  string_buffer_free_all (&buf);
  return result;
}

References all_reduction, buf, compute_all_reduction(), FOREACH, gen_recurse, gen_true(), load_printed_reductions(), OMP_PRAGMA_FOR_HEADER_C, OMP_PRAGMA_FOR_HEADER_F, pips_debug, prettyprint_language_is_fortran_p(), REDUCTION, reduction_as_str(), reductions_list, reductions_on_scalar(), reset_all_reduction(), statement_domain, statement_is_reduction(), strdup(), string_buffer_append(), string_buffer_free_all(), string_buffer_make(), and string_buffer_to_string().

Here is the call graph for this function:

remove_variable_from_reduction()

void remove_variable_from_reduction	(	reduction	red,
		entity	var
	)

Parameters

red	ed
var	ar

Definition at line 130 of file utils.c.

{
    variable_to_remove = var;
    dead_expressions = NIL;
    first_encountered_call = NULL;
    make_ref_exprs_stack();
 
    pips_debug(8, "removing %s from %s[%s]\n",
               entity_name(var),
               reduction_operator_tag_name
                  (reduction_operator_tag(reduction_op(red))),
               entity_name(reduction_variable(red)));
 
    gen_multi_recurse(reduction_reference(red),
                      expression_domain, expr_flt, expr_rwt,
                      reference_domain, ref_flt, gen_null,
                      NULL);
 
    gen_free_list(dead_expressions);
    free_ref_exprs_stack();
}

References dead_expressions, entity_name, expr_flt(), expr_rwt(), expression_domain, first_encountered_call, gen_free_list(), gen_multi_recurse(), gen_null(), NIL, pips_debug, reduction_op, reduction_operator_tag, reduction_operator_tag_name(), reduction_reference, reduction_variable, ref_flt(), reference_domain, and variable_to_remove.

Referenced by compute_one_summary_reduction(), update_compatible_reduction(), and update_reduction_under_effect().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_reduction_with_atomic()

bool replace_reduction_with_atomic

(

string

mod_name

)

end of it

cproto-generated files atomic.c

end of it

Parameters

mod_name

od_name

Definition at line 397 of file atomic.c.

                                                     {
  debug_on("REPLACE_REDUCTION_WITH_ATOMIC_DEBUG_LEVEL");
 
  bool result = process_reduced_loops(mod_name, DO_REPLACE);
 
  debug_off();
 
  return result;
}

References debug_off, debug_on, DO_REPLACE, and process_reduced_loops().

Here is the call graph for this function:

reset_cumulated_reductions()

void reset_cumulated_reductions

(

void

)

Referenced by cumulated_reductions(), reduction_atomization(), simd_remove_reductions(), and summary_reductions().

Here is the caller graph for this function:

reset_printed_reductions()

void reset_printed_reductions

(

void

)

Referenced by print_any_reductions(), and process_reduced_loops().

Here is the caller graph for this function:

reset_proper_reductions()

void reset_proper_reductions

(

void

)

Referenced by cumulated_reductions(), proper_reductions(), and reduction_propagation().

Here is the caller graph for this function:

same_reduction_p()

bool same_reduction_p	(	reduction	r1,
		reduction	r2
	)

Parameters

r1	1
r2	2

Definition at line 611 of file reductions.c.

{
    return ( (reference_equal_p(reduction_reference(r1),reduction_reference(r2))) &&
            (reduction_operator_tag(reduction_op(r1)) == reduction_operator_tag(reduction_op(r2))) );
}

References reduction_op, reduction_operator_tag, reduction_reference, and reference_equal_p().

Referenced by add_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

set_cumulated_reductions()

void set_cumulated_reductions

(

pstatement_reductions

)

Referenced by reduction_atomization(), simd_remove_reductions(), and summary_reductions().

Here is the caller graph for this function:

set_printed_reductions()

void set_printed_reductions

(

pstatement_reductions

)

Referenced by print_any_reductions(), and process_reduced_loops().

Here is the caller graph for this function:

set_proper_reductions()

void set_proper_reductions

(

pstatement_reductions

)

Referenced by cumulated_reductions(), and reduction_propagation().

Here is the caller graph for this function:

store_cumulated_reductions()

void store_cumulated_reductions	(	statement	,
		reductions
	)

Referenced by build_creductions_of_statement(), compute_cumulated_reductions(), and do_expression_reduction().

Here is the caller graph for this function:

store_or_update_cumulated_reductions()

void store_or_update_cumulated_reductions	(	statement	,
		reductions
	)

store_or_update_printed_reductions()

void store_or_update_printed_reductions	(	statement	,
		reductions
	)

store_or_update_proper_reductions()

void store_or_update_proper_reductions	(	statement	,
		reductions
	)

store_printed_reductions()

void store_printed_reductions	(	statement	,
		reductions
	)

store_proper_reductions()

void store_proper_reductions	(	statement	,
		reductions
	)

Referenced by pr_statement_flt().

Here is the caller graph for this function:

summary_reductions()

bool summary_reductions

(

const char *

module_name

)

handler for pipsmake input: module name output: TRUE side effects: stores the summary reductions to pipsdbm

Parameters

module_name

odule_name

Definition at line 106 of file reductions.c.

{
    reductions red;
 
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s\n", module_name);
 
    set_generic_effects_as_needed();
    set_current_module_entity(local_name_to_top_level_entity(module_name));
    set_current_module_statement((statement)
        db_get_memory_resource(DBR_CODE, module_name, true));
    set_cumulated_reductions((pstatement_reductions)
        db_get_memory_resource(DBR_CUMULATED_REDUCTIONS, module_name, true));
 
    red = compute_summary_reductions(get_current_module_entity());
 
    DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_REDUCTIONS, module_name, red);
 
    reset_cumulated_reductions();
    reset_current_module_statement();
    reset_current_module_entity();
    generic_effects_reset_all_methods();
 
    debug_off();
    return true;
}

References compute_summary_reductions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, generic_effects_reset_all_methods(), get_current_module_entity(), local_name_to_top_level_entity(), module_name(), pips_debug, reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_reductions(), set_current_module_entity(), set_current_module_statement(), and set_generic_effects_as_needed().

Here is the call graph for this function:

summary_to_proper_reference()

list summary_to_proper_reference	(	call	c,
		reference	r
	)

call.c

call.c

thus it is similar to summary effects call translations. I do reuse some functions there by generating fake effects... I think they should be cleaned so as to offer reference plus predicate translations, and then would be used by reductions and effects. Fabien. translation of a reference, based on effect translations... such an interface should be available? of reference

persistent!

of effect

of reference

Definition at line 45 of file call.c.

{
    effect e = make_simple_effect(r, /* persistent! */
                                  make_action_write_memory(),
                           make_approximation(is_approximation_exact, UU));
    list /* of effect */ lef, /* of reference */ lref = NIL;
 
    pips_debug(7, "reference to %s\n", entity_name(reference_variable(r)));
 
    lef = summary_effect_to_proper_effect(c, e);
 
    FOREACH (EFFECT, ef, lef) {
      lref = CONS(REFERENCE, effect_any_reference(ef), lref);
    }
 
    gen_map((gen_iter_func_t)gen_free, lef);
    gen_free_list(lef);
    return lref;
}

References CONS, EFFECT, effect_any_reference, entity_name, FOREACH, gen_free(), gen_free_list(), gen_map(), is_approximation_exact, make_action_write_memory(), make_approximation(), make_simple_effect, NIL, pips_debug, REFERENCE, reference_variable, summary_effect_to_proper_effect(), and UU.

Referenced by translate_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_reductions()

list translate_reductions

(

call

c

)

of reduction

Returns

the list of proper reduction applicable to the call according to the summary reduction computed earlier.

Parameters

c,the

call to check for proper reductions

of reduction

Definition at line 112 of file call.c.

{
    entity fun = call_function(c);
    list /* of reduction */ lr = NIL;
 
    if (!entity_module_p(fun))
        return NIL;
 
    FOREACH (REDUCTION, r, reductions_list(load_summary_reductions(fun))) {
      lr = gen_nconc(translate_reduction(c, r), lr);
    }
 
    return lr;
}

References call_function, entity_module_p(), FOREACH, gen_nconc(), load_summary_reductions(), NIL, REDUCTION, reductions_list, and translate_reduction().

Referenced by pr_call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

update_compatible_reduction()

bool update_compatible_reduction	(	reduction *	pr,
		entity	var,
		list	le,
		reductions	reds
	)

what to do with reduction *pr for variable var under effects le and reductions reds.

returns whether worth to go on. conditions:

some reduction already available

must update the reduction with the encountered effects

else now no new reduction waas found, must check *pr against effects

some reduction

stores for latter cleaning

Parameters

pr	r
var	ar
le	of effect
reds	eds

Definition at line 285 of file utils.c.

{
    reduction found = NULL;
 
    if (!find_reduction_of_var(var, reds, &found))
        return false;
 
    if (found)
    {
      if (!reduction_none_p(*pr)) /* some reduction already available */
        return merge_two_reductions(*pr, found);
      else { /* must update the reduction with the encountered effects */
        FOREACH (ENTITY, e,reduction_dependences(*pr)) {
          remove_variable_from_reduction(found, e);
        }
        free_reduction(*pr); *pr = found;
        return true;
      }
    }
    /* else
     * now no new reduction waas found, must check *pr against effects
     */
    if (!reduction_none_p(*pr)) /* some reduction */
      {
        FOREACH (EFFECT, e, le) {
    if(!store_effect_p(e)) continue;
          if (!update_reduction_under_effect(*pr, e)) {
            DEBUG_REDUCTION(8, "kill of ", *pr);
            pips_debug(8, "under effect to %s\n",
                       entity_name(effect_variable(e)));
            return false;
          }
        }
    }
    else
    {
      FOREACH (EFFECT, e, le) {
        if(!store_effect_p(e)) continue;
        if (entities_may_conflict_p(effect_variable(e), var))
          return false;
        else if (effect_write_p(e)) /* stores for latter cleaning */
          reduction_dependences(*pr) = gen_once(effect_variable(e),
                                                reduction_dependences(*pr));
      }
    }
    return true;
}

References DEBUG_REDUCTION, EFFECT, effect_variable, effect_write_p, entities_may_conflict_p(), ENTITY, entity_name, find_reduction_of_var(), FOREACH, free_reduction(), gen_once(), merge_two_reductions(), pips_debug, reduction_dependences, reduction_none_p, remove_variable_from_reduction(), store_effect_p(), and update_reduction_under_effect().

Referenced by build_reduction_of_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

update_compatible_reduction_with()

bool update_compatible_reduction_with	(	reduction *	pr,
		entity	var,
		reduction	r
	)

update *pr according to r for variable var r is not touched.

else same var and no conflict

else are they compatible?

ok, let us merge them

Parameters

pr	r
var	ar

Definition at line 260 of file utils.c.

                                                                              {
  if(reduction_variable(r) != var)
    return !entities_may_conflict_p(var, reduction_variable(r));
 
  /* else same var and no conflict */
  if(reduction_none_p(*pr)) {
    free_reduction(*pr);
    *pr = copy_reduction(r);
    return true;
  }
  /* else are they compatible?
   */
  if(reduction_tag(*pr) != reduction_tag(r))
    return false;
  /* ok, let us merge them
   */
  return merge_two_reductions(*pr, copy_reduction(r));
}

References copy_reduction(), entities_may_conflict_p(), free_reduction(), merge_two_reductions(), reduction_none_p, reduction_tag, and reduction_variable.

Referenced by compatible_reduction_of_var().

Here is the call graph for this function:

Here is the caller graph for this function:

update_cumulated_reductions()

void update_cumulated_reductions	(	statement	,
		reductions
	)

update_printed_reductions()

void update_printed_reductions	(	statement	,
		reductions
	)

update_proper_reductions()

void update_proper_reductions	(	statement	,
		reductions
	)

update_reduction_under_effect()

bool update_reduction_under_effect	(	reduction	red,
		effect	eff
	)

REDUCTION is dead if the reduction variable is affected

else

now var is written

Parameters

red	ed
eff	ff

Definition at line 155 of file utils.c.

{
    entity var = effect_variable(eff);
    bool updated = false;
 
    pips_debug(7, "reduction %s[%s] under effect %s on %s\n",
               reduction_operator_tag_name
                  (reduction_operator_tag(reduction_op(red))),
               entity_name(reduction_variable(red)),
               effect_write_p(eff)? "W": "R",
               entity_name(effect_variable(eff)));
 
    if(!store_effect_p(eff)) {
      return true;
    }
 
 
    /* REDUCTION is dead if the reduction variable is affected
     */
    if (entities_may_conflict_p(reduction_variable(red),var))
    {
        reduction_operator_tag(reduction_op(red)) =
            is_reduction_operator_none;
        return false;
    }
    /* else */
 
    if (effect_read_p(eff)) return true;
 
    /* now var is written */
    FOREACH (ENTITY, e, reduction_dependences(red)) {
      if (entities_may_conflict_p(var, e)) {
        updated = true;
        remove_variable_from_reduction(red, e);
      }
    }
 
    if (updated)
    {
        gen_free_list(reduction_dependences(red));
        reduction_dependences(red) =
             referenced_variables(reduction_reference(red));
    }
 
    return true;
}

References effect_read_p, effect_variable, effect_write_p, entities_may_conflict_p(), ENTITY, entity_name, FOREACH, gen_free_list(), is_reduction_operator_none, pips_debug, reduction_dependences, reduction_op, reduction_operator_tag, reduction_operator_tag_name(), reduction_reference, reduction_variable, referenced_variables(), remove_variable_from_reduction(), and store_effect_p().

Referenced by update_compatible_reduction().

Here is the call graph for this function:

Here is the caller graph for this function: