delay.c File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "resources.h"
#include "misc.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "preprocessor.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "properties.h"
#include "callgraph.h"
#include "transformations.h"
#include "dg.h"
#include "graph.h"
#include "control.h"
#include "ricedg.h"
#include "effects-simple.h"
#include "accel-util.h"

Include dependency graph for delay.c:

Go to the source code of this file.

Data Structures
struct	conflict_t
	helper for do_recurse_statements_conflict_p More...
struct	context

Typedefs
typedef dg_arc_label	arc_label
typedef dg_vertex_label	vertex_label

Functions
static bool	do_remove_preference (cell c)
	helper to transform preferences in references More...
void	remove_preferences (void *obj)
	entry point to transform preferences in references More...
static bool	simd_load_call_p (call c)
static bool	simd_work_call_p (call c)
static bool	simd_store_call_p (call c)
bool	simd_load_stat_p (statement stat)
bool	simd_work_stat_p (statement stat)
bool	simd_store_stat_p (statement stat)
bool	simd_dma_stat_p (statement stat)
	This function returns true if the statement is a simd loadsave statement. More...
bool	simd_stat_p (statement stat)
	This function returns true if the statement is a simd statement. More...
static bool	dma_conflict_p (conflict c)
static bool	statements_conflict_p (statement s0, statement s1)
	checks if there exist a conflict between s0 and s1 according to the dependency graph More...
static bool	statements_conflict_relaxed_p (statement s0, statement s1, bool load_p)
	same as statements_conflict_p but W-* conflicts are ignored if load_p, R-* conflicts are ignored if not load_p More...
static bool	dma_statements_conflict_p (statement s0, statement s1)
static void	do_recurse_statements_conflict_p (statement s, conflict_t *c)
	helper for recurse_statements_conflict_p More...
static bool	recurse_statements_conflict_p (statement s, statement in)
	checks if there is a conflict between s and any statement in in More...
static context	context_dup (context *c)
static void	delay_communications_statement (statement, context *, list *block)
static void	delay_communications_sequence (sequence s, context *c, list *block)
static void	create_block_if_needed (statement *s, list **block)
static void	insert_statement_in_block (statement s, statement inserted, bool before, list *block)
static void	manage_conflicts (statement s, context *c, bool before, list *block)
static void	delay_communications_call (statement s, context *c, list *block)
static void	delay_communications_test (statement s, context *c, list *block)
static void	delay_communications_anyloop (statement s, context *c, list *block)
static statement	translate_arguments (call ca, statement s)
static void	promote_local_entities (statement s, entity caller, statement caller_statement)
	if some local variables are going to be accessed inter procedurally, promote them to global variables More...
static void	do_delay_communications_interprocedurally (call ca, context *c)
static void	delay_communications_intraprocedurally (statement module_stat, context *c)
	transform each caller into a load / call /store sequence More...
static void	delay_communications_interprocedurally (context *c)
static void	delay_communications_init ()
static void	delay_communications_reset ()
bool	delay_load_communications (char *module_name)
	This phase looks for load or save statements that can be put out of the loop body and move these statements, if possible. More...
bool	delay_load_communications_inter (char *module_name)
bool	delay_load_communications_intra (char *module_name)
bool	delay_store_communications (char *module_name)
bool	delay_store_communications_inter (char *module_name)
bool	delay_store_communications_intra (char *module_name)
static bool	dmas_invert_p (statement s0, statement s1)
static void	do_remove_redundant_communications_in_sequence (sequence s, bool *need_flatten)
static void	select_independent_dmas (list *stats, statement parent)
static bool	do_remove_redundant_communications_in_anyloop (statement parent, statement body)
static void	do_remove_redundant_communications_in_loop (loop l, bool *need_flatten)
static void	do_remove_redundant_communications_in_whileloop (whileloop l, bool *need_flatten)
static void	do_remove_redundant_communications_in_forloop (forloop l, bool *need_flatten)
static bool	remove_redundant_communications (statement s)
static bool	delay_communications (const char *module_name)
bool	delay_communications_inter (const char *module_name)
bool	delay_communications_intra (const char *module_name)

Variables
static bool	delay_communications_interprocedurally_p
static graph	dependence_graph =graph_undefined
static bool	__delay_communications_patch_properties

Detailed Description

Author

Serge Guelton serge.nosp@m..gue.nosp@m.lton@.nosp@m.enst.nosp@m.-bret.nosp@m.agne.nosp@m..fr

Version

Date

2010-12-15

Implementation of inter procedural load / store delaying

Definition in file delay.c.

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Definition at line 63 of file delay.c.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 64 of file delay.c.

Function Documentation

context_dup()

static context context_dup ( context *  c )

static

Definition at line 262 of file delay.c.

                                       {
  // FI: Missing initializer... I add statement_undefined...
  context cp = { c->result, gen_copy_seq(c->stats), c->backward, c->need_flatten , c->caller, statement_undefined };
  return cp;
}

References context::backward, context::caller, cp, gen_copy_seq(), context::need_flatten, context::result, statement_undefined, and context::stats.

Referenced by delay_communications_anyloop(), and delay_communications_test().

Here is the call graph for this function:

Here is the caller graph for this function:

create_block_if_needed()

static void create_block_if_needed ( statement *  s, list **  block  )

static

Definition at line 279 of file delay.c.

                                                               {
    if(!statement_block_p(*s) && !*block) {
        pips_assert("declaration must be in a block\n",!declaration_statement_p(*s));
        statement scopy = instruction_to_statement(statement_instruction(*s));
        statement_instruction(*s)=instruction_undefined;
        list tmp = CONS(STATEMENT,scopy,NIL);
        update_statement_instruction(*s,make_instruction_block(tmp));
        *block=&sequence_statements(statement_sequence(*s));
        *s=scopy;
 
    }
}

References CONS, declaration_statement_p(), instruction_to_statement(), instruction_undefined, make_instruction_block(), NIL, pips_assert, sequence_statements, STATEMENT, statement_block_p, statement_instruction, statement_sequence(), and update_statement_instruction().

Referenced by insert_statement_in_block().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications()

static bool delay_communications ( const char *  module_name )

static

Get the code of the module.

clean badly generated sequences

Definition at line 924 of file delay.c.

{
    /* Get the code of the module. */
    entity module = module_name_to_entity(module_name);
    statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
    set_current_module_entity( module);
    set_current_module_statement( module_stat);
    set_ordering_to_statement(module_stat);
 
    set_proper_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true)
    );
    remove_preferences(get_proper_rw_effects());
    set_cumulated_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true)
    );
    dependence_graph = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
    debug_on("DELAY_COMMUNICATIONS_DEBUG_LEVEL");
    bool need_flatten=
        remove_redundant_communications(module_stat);
 
    /* clean badly generated sequences */
    clean_up_sequences(module_stat);
 
    if(need_flatten)
        statement_flatten_declarations(module,module_stat);
 
 
    pips_assert("Statement is consistent\n" , statement_consistent_p(module_stat));
 
    module_reorder(module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(module_stat));
 
    debug_off();
    dependence_graph=graph_undefined;
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_ordering_to_statement();
 
    return true;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dependence_graph, get_proper_rw_effects(), graph_undefined, module, module_name(), module_name_to_entity(), module_reorder(), pips_assert, remove_preferences(), remove_redundant_communications(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), statement_consistent_p(), and statement_flatten_declarations().

Referenced by delay_communications_inter(), and delay_communications_intra().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_anyloop()

static void delay_communications_anyloop ( statement  s, context *  c, list *  block  )

static

first step is to check conflict with the head

then we check if there is a conflict inside the loop. In that case better insert before the loop than inside

then we propagate the dma inside the body

then we check for conflicts with indices or over iterations

if statements have been moved outside the loop then we (may) need to flatten

Definition at line 407 of file delay.c.

                                                                               {
  statement body=statement_undefined;
  if(statement_loop_p(s)) body =loop_body(statement_loop(s));
  else if(statement_forloop_p(s)) body =forloop_body(statement_forloop(s));
  else if(statement_whileloop_p(s)) body =whileloop_body(statement_whileloop(s));
  pips_assert("all loops have body\n",!statement_undefined_p(s));
 
  /* first step is to check conflict with the head */
  manage_conflicts(s,c,!c->backward,block);
  /* then we check if there is a conflict inside the loop.
   * In that case better insert before the loop than inside */
  list tstats = gen_copy_seq(c->stats);
  FOREACH(STATEMENT,st,tstats) {
    if(recurse_statements_conflict_p(st,body) ) { // conflict with other iterations
      insert_statement_in_block(s,st,!c->backward,block);
      gen_remove_once(&c->stats,st);
    }
  }
  gen_free_list(tstats);
 
  /* then we propagate the dma inside the body */
  context cb = context_dup(c);
  delay_communications_statement(body,c,NULL);
 
 
  /* then we check for conflicts with indices or over iterations */
  tstats = gen_copy_seq(c->stats);
  FOREACH(STATEMENT,st,tstats) {
    if(statements_conflict_p(st,s) ||// conflict with the iteration
            recurse_statements_conflict_p(st,body) ) { // conflict with other iterations
      insert_statement_in_block(body,st,c->backward,NULL);
      gen_remove_once(&c->stats,st);
    }
  }
  gen_free_list(tstats);
  /* if statements have been moved outside the loop
   * then we (may) need to flatten
   */
  FOREACH(STATEMENT,st,c->stats) {
      if(gen_chunk_undefined_p(gen_find_eq(st,cb.stats))) {
          c->need_flatten|=true;
          break;
      }
  }
  gen_free_list(cb.stats);
 
}

References context::backward, context_dup(), delay_communications_statement(), FOREACH, forloop_body, gen_chunk_undefined_p, gen_copy_seq(), gen_find_eq(), gen_free_list(), gen_remove_once(), insert_statement_in_block(), loop_body, manage_conflicts(), context::need_flatten, pips_assert, recurse_statements_conflict_p(), STATEMENT, statement_forloop(), statement_forloop_p(), statement_loop(), statement_loop_p(), statement_undefined, statement_undefined_p, statement_whileloop(), statement_whileloop_p(), statements_conflict_p(), context::stats, and whileloop_body.

Referenced by delay_communications_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_call()

static void delay_communications_call ( statement  s, context *  c, list *  block  )

static

memorize additional dma

Definition at line 316 of file delay.c.

                                                                            {
  manage_conflicts(s,c,!c->backward,block);
  /* memorize additional dma */
  if( (c->backward && simd_load_stat_p(s)) ||
          (!c->backward && simd_store_stat_p(s)) ) {
    c->stats=CONS(STATEMENT,copy_statement(s),c->stats);
    intptr_t o = statement_ordering(s);
    update_statement_instruction(s,make_continue_instruction());
    statement_ordering(s)=o;
    gen_free_list(statement_declarations(s)); statement_declarations(s)=NIL;
    if (!empty_comments_p(statement_comments(s)))
      free(statement_comments(s));
    statement_comments(s)=empty_comments;
  }
}

References context::backward, CONS, copy_statement(), empty_comments, empty_comments_p(), free(), gen_free_list(), intptr_t, make_continue_instruction(), manage_conflicts(), NIL, simd_load_stat_p(), simd_store_stat_p(), STATEMENT, statement_comments, statement_declarations, statement_ordering, context::stats, and update_statement_instruction().

Referenced by delay_communications_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_init()

static void delay_communications_init ( )

static

Definition at line 589 of file delay.c.

                                        {
    pips_assert("reset called",graph_undefined_p(dependence_graph));
    __delay_communications_patch_properties = delay_communications_interprocedurally_p &&
        ENDP(callees_callees((callees)db_get_memory_resource(DBR_CALLERS,module_local_name(get_current_module_entity()), true))); 
    if(__delay_communications_patch_properties)
        delay_communications_interprocedurally_p=false;
}

References __delay_communications_patch_properties, callees_callees, db_get_memory_resource(), delay_communications_interprocedurally_p, dependence_graph, ENDP, get_current_module_entity(), graph_undefined_p, module_local_name(), and pips_assert.

Referenced by delay_load_communications(), and delay_store_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_inter()

bool delay_communications_inter

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 970 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = true;
  return delay_communications(module_name);
}

References delay_communications(), delay_communications_interprocedurally_p, and module_name().

Here is the call graph for this function:

delay_communications_interprocedurally()

static void delay_communications_interprocedurally ( context *  c )

static

Definition at line 561 of file delay.c.

                                                               {
    list callers = callees_callees((callees)db_get_memory_resource(DBR_CALLERS,module_local_name(get_current_module_entity()), true));
    if(ENDP(callers)) {
        pips_user_warning("no caller for function `%s', falling back to intra-procedural delaying\n",get_current_module_name());
        delay_communications_intraprocedurally(get_current_module_statement(),c);
    }
    else {
        list callers_statement = callers_to_statements(callers);
 
        for(list citer=callers,siter=callers_statement;!ENDP(citer);POP(citer),POP(siter)) {
            c->caller=module_name_to_entity( STRING(CAR(citer)) );
            c->caller_statement = STATEMENT(CAR(siter));
            gen_context_recurse(c->caller_statement,c,call_domain,gen_true2,do_delay_communications_interprocedurally);
            clean_up_sequences(c->caller_statement);
        }
 
        for(list citer=callers,siter=callers_statement;!ENDP(citer);POP(citer),POP(siter)) {
            string caller_name = STRING(CAR(citer));
            statement caller_statement = STATEMENT(CAR(siter));
            module_reorder(caller_statement);
            DB_PUT_MEMORY_RESOURCE(DBR_CODE, caller_name,caller_statement);
            DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, caller_name,compute_callees(caller_statement));
        }
    }
}

References call_domain, callees_callees, context::caller, caller_name, context::caller_statement, callers_to_statements(), CAR, clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, delay_communications_intraprocedurally(), do_delay_communications_interprocedurally(), ENDP, gen_context_recurse, gen_true2(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), module_local_name(), module_name_to_entity(), module_reorder(), pips_user_warning, POP, STATEMENT, and STRING.

Referenced by delay_load_communications(), and delay_store_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_intra()

bool delay_communications_intra

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 974 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = false;
  return delay_communications(module_name);
}

References delay_communications(), delay_communications_interprocedurally_p, and module_name().

Here is the call graph for this function:

delay_communications_intraprocedurally()

static void delay_communications_intraprocedurally ( statement  module_stat, context *  c  )

static

transform each caller into a load / call /store sequence

Definition at line 556 of file delay.c.

                                                                                      {
    FOREACH(STATEMENT,s,c->stats)
        insert_statement(module_stat,s,c->backward);
    gen_free_list(c->stats);c->stats=NIL;
}

References context::backward, FOREACH, gen_free_list(), insert_statement(), NIL, STATEMENT, and context::stats.

Referenced by delay_communications_interprocedurally(), delay_load_communications(), and delay_store_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_reset()

static void delay_communications_reset ( )

static

Definition at line 596 of file delay.c.

                                         {
    pips_assert("init called",!graph_undefined_p(dependence_graph));
    if(__delay_communications_patch_properties)
        delay_communications_interprocedurally_p=true;
    dependence_graph=graph_undefined;
 
}

References __delay_communications_patch_properties, delay_communications_interprocedurally_p, dependence_graph, graph_undefined, graph_undefined_p, and pips_assert.

Referenced by delay_load_communications(), and delay_store_communications().

Here is the caller graph for this function:

delay_communications_sequence()

static void delay_communications_sequence ( sequence  s, context *  c, list *  block  )

static

Definition at line 270 of file delay.c.

                                                                               {
  pips_assert("true", block==block);
  list stats = gen_copy_seq(sequence_statements(s));
  if(c->backward) stats=gen_nreverse(stats); //reverse the walking when performing backward movements
  FOREACH(STATEMENT,st,stats) {
    delay_communications_statement(st,c,&sequence_statements(s));
  }
  gen_free_list(stats);
}

References context::backward, delay_communications_statement(), FOREACH, gen_copy_seq(), gen_free_list(), gen_nreverse(), pips_assert, sequence_statements, and STATEMENT.

Referenced by delay_communications_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_statement()

static void delay_communications_statement ( statement  s, context *  c, list *  block  )

static

we could do better

Definition at line 455 of file delay.c.

                                                                                 {
  instruction i = statement_instruction(s);
  switch(instruction_tag(i)) {
    case is_instruction_expression:/* we could do better */
    case is_instruction_call:
      delay_communications_call(s,c,block);break;
    case is_instruction_sequence:
      delay_communications_sequence(instruction_sequence(i),c,NULL);break;
    case is_instruction_test:
      delay_communications_test(s,c,NULL);break;
    case is_instruction_loop:
    case is_instruction_whileloop:
    case is_instruction_forloop:
      delay_communications_anyloop(s,c,NULL);break;
    default:
      pips_user_warning("not implemented yet, full memory barrier is assumed\n");
      {
          list tstats= gen_copy_seq(c->stats);
          FOREACH(STATEMENT,st,tstats) {
              insert_statement_in_block(s,st,!c->backward,block);
              gen_remove_once(&c->stats,st);
          }
          gen_free_list(tstats);
      }
 
  };
  pips_assert("everything is ok",statement_consistent_p(s));
}

References context::backward, delay_communications_anyloop(), delay_communications_call(), delay_communications_sequence(), delay_communications_test(), FOREACH, gen_copy_seq(), gen_free_list(), gen_remove_once(), insert_statement_in_block(), instruction_sequence, instruction_tag, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_whileloop, pips_assert, pips_user_warning, STATEMENT, statement_consistent_p(), statement_instruction, and context::stats.

Referenced by delay_communications_anyloop(), delay_communications_sequence(), delay_communications_test(), delay_load_communications(), and delay_store_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_communications_test()

static void delay_communications_test ( statement  s, context *  c, list *  block  )

static

explore both branches independently

manage state consistency after s : currently very pessimistic: if a dma is made on a branch, it must be done at the end of the branch. A more elaborated version could be to check that same pointers are stored and that they can be merged later ...

the same for the false branch

now we have the opposite case: a dma was made on a branch but not on the other one, in that case we must do it at the end of the other branch

true branch

false branch

insert it if it's missing somewhere

Definition at line 332 of file delay.c.

                                                                            {
  manage_conflicts(s,c,!c->backward, block);
  /* explore both branches independently */
  test t = statement_test(s);
  context c0 = context_dup(c), c1=context_dup(c);
  delay_communications_statement(test_true(t),&c0,NULL);
  delay_communications_statement(test_false(t),&c1,NULL);
  /* manage state consistency after s :
   * currently very pessimistic: if a dma is made on a branch, it must be
   * done at the end of the branch.
   * A more elaborated version could be to check that same pointers are stored
   * and that they can be merged later ...
   */
  list tstats = gen_copy_seq(c0.stats);
  FOREACH(STATEMENT,st0,tstats) {
    intptr_t o = statement_ordering(st0);
    bool new = true;
    FOREACH(STATEMENT,st,c->stats) {
      if(statement_ordering(st) == o ) {
        new=false;
        break;
      }
    }
    if(new) {
      insert_statement_in_block(test_true(t),copy_statement(st0),c->backward,NULL);
      gen_remove_once(&c0.stats,st0);
      gen_remove_once(&c->stats,st0);
    }
  }
  gen_free_list(tstats);
  /* the same for the false branch */
  tstats = gen_copy_seq(c1.stats);
  FOREACH(STATEMENT,st1,tstats) {
    intptr_t o = statement_ordering(st1);
    bool new = true;
    FOREACH(STATEMENT,st,c->stats) {
      if(statement_ordering(st) == o ) {
        new=false;
        break;
      }
    }
    if(new) {
      insert_statement_in_block(test_false(t),copy_statement(st1),c->backward,NULL);
      gen_remove_once(&c1.stats,st1);
      gen_remove_once(&c->stats,st1);
    }
  }
  gen_free_list(tstats);
  /* now we have the opposite case: a dma was made on a branch
   * but not on the other one,
   * in that case we must do it at the end of the other branch
   */
  tstats = gen_copy_seq(c->stats);
  FOREACH(STATEMENT,st,tstats) {
    intptr_t o = statement_ordering(st);
    /* true branch */
    bool tfound =false,ffound=false;
    FOREACH(STATEMENT,st0,c0.stats)
      if((tfound= (o == statement_ordering(st0)))) break;
    /* false branch */
    FOREACH(STATEMENT,st1,c1.stats)
      if((ffound= (o == statement_ordering(st1)))) break;
    /* insert it if it's missing somewhere */
    if(tfound && !ffound ) {
      insert_statement_in_block(test_true(t),copy_statement(st),c->backward,block);
      gen_remove_once(&c->stats,st);
    }
    if(!tfound && ffound ) {
      insert_statement_in_block(test_false(t),copy_statement(st),c->backward,block);
      gen_remove_once(&c->stats,st);
    }
  }
  gen_free_list(tstats);
}

References context::backward, context_dup(), copy_statement(), delay_communications_statement(), FOREACH, gen_copy_seq(), gen_free_list(), gen_remove_once(), insert_statement_in_block(), intptr_t, manage_conflicts(), STATEMENT, statement_ordering, statement_test(), context::stats, test_false, and test_true.

Referenced by delay_communications_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_load_communications()

bool delay_load_communications

(

char *

module_name

)

This phase looks for load or save statements that can be put out of the loop body and move these statements, if possible.

Get the code of the module.

Go through all the statements

then a backward translation

propagate inter procedurally , except if we have no caller

clean badly generated sequences

Parameters

module_name

odule_name

Definition at line 607 of file delay.c.

{
    /* Get the code of the module. */
    entity module = module_name_to_entity(module_name);
    statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
    set_ordering_to_statement(module_stat);
    set_current_module_entity( module);
    set_current_module_statement( module_stat);
    set_proper_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true)
    );
    remove_preferences(get_proper_rw_effects());
    set_cumulated_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true)
    );
 
 
    debug_on("DELAY_COMMUNICATIONS_DEBUG_LEVEL");
    delay_communications_init();
    dependence_graph = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
    /* Go through all the statements */
    context c = { true, NIL, true, false , NULL, NULL };
 
    /* then a backward translation */
    delay_communications_statement(module_stat,&c,NULL);
 
    /* propagate inter procedurally , except if we have no caller*/
    if(delay_communications_interprocedurally_p)
        delay_communications_interprocedurally(&c);
    else
        delay_communications_intraprocedurally(module_stat,&c);
 
    if(c.need_flatten)
        statement_flatten_declarations(module,module_stat);
 
    /* clean badly generated sequences */
    clean_up_sequences(module_stat);
 
    delay_communications_reset();
 
 
    pips_assert("Statement is consistent\n" , statement_consistent_p(module_stat));
 
    module_reorder(module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(module_stat));
 
    debug_off();
 
    reset_current_module_entity();
    reset_ordering_to_statement();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
 
    return c.result;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, delay_communications_init(), delay_communications_interprocedurally(), delay_communications_interprocedurally_p, delay_communications_intraprocedurally(), delay_communications_reset(), delay_communications_statement(), dependence_graph, false, get_proper_rw_effects(), module, module_name(), module_name_to_entity(), module_reorder(), context::need_flatten, NIL, pips_assert, remove_preferences(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), context::result, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), statement_consistent_p(), and statement_flatten_declarations().

Referenced by delay_load_communications_inter(), and delay_load_communications_intra().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_load_communications_inter()

bool delay_load_communications_inter

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 665 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = true;
  return delay_load_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_load_communications(), and module_name().

Here is the call graph for this function:

delay_load_communications_intra()

bool delay_load_communications_intra

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 669 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = false;
  return delay_load_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_load_communications(), and module_name().

Here is the call graph for this function:

delay_store_communications()

bool delay_store_communications

(

char *

module_name

)

Get the code of the module.

Go through all the statements

a first forward translation

propagate inter procedurally , except if we have no caller

clean badly generated sequences

Parameters

module_name

odule_name

Definition at line 674 of file delay.c.

{
    /* Get the code of the module. */
    entity module = module_name_to_entity(module_name);
    statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
    set_ordering_to_statement(module_stat);
    set_current_module_entity( module);
    set_current_module_statement( module_stat);
    set_proper_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true)
    );
    remove_preferences(get_proper_rw_effects());
    set_cumulated_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true)
    );
    delay_communications_init();
 
    dependence_graph = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
    debug_on("DELAY_COMMUNICATIONS_DEBUG_LEVEL");
 
 
 
    /* Go through all the statements */
    context c = { true, NIL, false, false, NULL, NULL };
 
    /* a first forward translation */
    delay_communications_statement(module_stat,&c,NULL);
 
    /* propagate inter procedurally , except if we have no caller*/
    if(delay_communications_interprocedurally_p)
        delay_communications_interprocedurally(&c);
    else
        delay_communications_intraprocedurally(module_stat,&c);
 
    if(c.need_flatten)
        statement_flatten_declarations(module,module_stat);
 
    /* clean badly generated sequences */
    clean_up_sequences(module_stat);
 
    delay_communications_reset();
 
    pips_assert("Statement is consistent\n" , statement_consistent_p(module_stat));
 
    module_reorder(module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(module_stat));
 
    debug_off();
 
    reset_current_module_entity();
    reset_ordering_to_statement();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
 
    return c.result;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, delay_communications_init(), delay_communications_interprocedurally(), delay_communications_interprocedurally_p, delay_communications_intraprocedurally(), delay_communications_reset(), delay_communications_statement(), dependence_graph, get_proper_rw_effects(), module, module_name(), module_name_to_entity(), module_reorder(), context::need_flatten, NIL, pips_assert, remove_preferences(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), context::result, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), statement_consistent_p(), and statement_flatten_declarations().

Referenced by delay_store_communications_inter(), and delay_store_communications_intra().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_store_communications_inter()

bool delay_store_communications_inter

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 733 of file delay.c.

                                                          {
  delay_communications_interprocedurally_p = true;
  return delay_store_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_store_communications(), and module_name().

Here is the call graph for this function:

delay_store_communications_intra()

bool delay_store_communications_intra

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 737 of file delay.c.

                                                          {
  delay_communications_interprocedurally_p = false;
  return delay_store_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_store_communications(), and module_name().

Here is the call graph for this function:

dma_conflict_p()

static bool dma_conflict_p ( conflict  c )

static

be conservative

Definition at line 142 of file delay.c.

{
    effect source = conflict_source(c),
           sink = conflict_sink(c);
    descriptor dsource = effect_descriptor(source),
               dsink = effect_descriptor(sink);
    if(descriptor_convex_p(dsource) && descriptor_convex_p(dsink))
    {
        Psysteme psource = descriptor_convex(dsource),
                 psink = descriptor_convex(dsink);
        return !(sc_inclusion_p(psink,psource) || sc_inclusion_p(psource,psink));
    }
    /* be conservative */
    return true;
}

References conflict_sink, conflict_source, descriptor_convex, descriptor_convex_p, effect_descriptor, and sc_inclusion_p.

Referenced by dma_statements_conflict_p().

Here is the caller graph for this function:

dma_statements_conflict_p()

static bool dma_statements_conflict_p ( statement  s0, statement  s1  )

static

Definition at line 216 of file delay.c.

                                                                  {
    FOREACH(VERTEX,v,graph_vertices(dependence_graph)) {
        statement s = vertex_to_statement(v);
        if(statement_ordering(s) == statement_ordering(s0) || statement_ordering(s) == statement_ordering(s1)) {
            intptr_t expected = statement_ordering(s) == statement_ordering(s0) ? statement_ordering(s1) : statement_ordering(s0);
            FOREACH(SUCCESSOR,su,vertex_successors(v)) {
                if(statement_ordering(vertex_to_statement(successor_vertex(su))) == expected ) {
                    FOREACH(CONFLICT,c,dg_arc_label_conflicts(successor_arc_label(su)))
                        if(dma_conflict_p(c)) return true;
                }
            }
        }
    }
  return false;
}

References CONFLICT, dependence_graph, dg_arc_label_conflicts, dma_conflict_p(), FOREACH, graph_vertices, intptr_t, s1, statement_ordering, SUCCESSOR, successor_arc_label, successor_vertex, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by do_recurse_statements_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

dmas_invert_p()

static bool dmas_invert_p ( statement  s0, statement  s1  )

static

this occurs when structures are involved

dma annihilates

Definition at line 742 of file delay.c.

                                                      {
    pips_assert("called on dmas",simd_dma_stat_p(s0) && simd_dma_stat_p(s1));
    list p_reg = load_cumulated_rw_effects_list(s0);
    list s_reg = load_cumulated_rw_effects_list(s1);
    list pr=NIL,pw=NIL,sr=NIL,sw=NIL;
    FOREACH(REGION,r,p_reg) {
        if(array_reference_p(region_any_reference(r))) {
            if(region_write_p(r)) {
                pw=CONS(REGION,r,pw);
            }
            else {
                pr=CONS(REGION,r,pr);
            }
        }
    }
    FOREACH(REGION,r,s_reg) {
        if(array_reference_p(region_any_reference(r))) {
            if(region_write_p(r)) {
                sw=CONS(REGION,r,sw);
            }
            else {
                sr=CONS(REGION,r,sr);
            }
        }
    }
    /* this occurs when structures are involved */
    if( ENDP(sw) ||
            ENDP(sr) ||
            ENDP(pw) ||
            ENDP(pr)) {
        pips_user_warning("regions for dma not properly computed\n");
        return false;
    }
    else {
        /* dma annihilates */
        bool annihilate = gen_length(pw) == gen_length(sr) &&
            gen_length(pr) == gen_length(sw) ;
        if( annihilate) {
            for(list i=pw,j=sr;!ENDP(i)&&!ENDP(j);POP(i),POP(j)) {
                region ri = REGION(CAR(i)),
                       rj = REGION(CAR(j));
                if(!( annihilate = (reference_equal_p(region_any_reference(ri),region_any_reference(rj)) &&
                                sc_equal_p(region_system(ri),region_system(rj)) )
                    ) ) break;
 
            }
            if(annihilate) {
                for(list i=sw,j=pr;!ENDP(i)&&!ENDP(j);POP(i),POP(j)) {
                    region ri = REGION(CAR(i)),
                           rj = REGION(CAR(j));
                    if(!( annihilate = (reference_equal_p(region_any_reference(ri),region_any_reference(rj)) &&
                                    sc_equal_p(region_system(ri),region_system(rj)) )
                        ) ) break;
 
                }
            }
        }
        return annihilate;
    }
}

References array_reference_p(), CAR, CONS, ENDP, FOREACH, gen_length(), load_cumulated_rw_effects_list(), NIL, pips_assert, pips_user_warning, POP, reference_equal_p(), region, REGION, region_any_reference, region_system, region_write_p, s1, sc_equal_p, and simd_dma_stat_p().

Referenced by do_remove_redundant_communications_in_anyloop(), and do_remove_redundant_communications_in_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

do_delay_communications_interprocedurally()

static void do_delay_communications_interprocedurally ( call  ca, context *  c  )

static

there should be checks there !

Definition at line 542 of file delay.c.

                                                                           {
  if(same_entity_p(call_function(ca),get_current_module_entity())) {
    statement parent = (statement) gen_get_ancestor(statement_domain,ca);
    FOREACH(STATEMENT,s,c->stats) {
      promote_local_entities(s,c->caller,c->caller_statement);
      statement new = translate_arguments(ca,s);
      /* there should be checks there ! */
      insert_statement(parent,new,c->backward);
    }
  }
}

References context::backward, call_function, context::caller, context::caller_statement, FOREACH, gen_get_ancestor(), get_current_module_entity(), insert_statement(), promote_local_entities(), same_entity_p(), STATEMENT, statement_domain, context::stats, and translate_arguments().

Referenced by delay_communications_interprocedurally().

Here is the call graph for this function:

Here is the caller graph for this function:

do_recurse_statements_conflict_p()

static void do_recurse_statements_conflict_p ( statement  s, conflict_t *  c  )

static

helper for recurse_statements_conflict_p

Definition at line 239 of file delay.c.

                                                                         {
    if(statement_ordering(s) == statement_ordering(c->s))
        c->conflict=dma_statements_conflict_p(s,c->s);
    else if((c->conflict=statements_conflict_relaxed_p(c->s,s,simd_load_stat_p(c->s))))
            gen_recurse_stop(0);
}

References conflict_t::conflict, dma_statements_conflict_p(), gen_recurse_stop(), conflict_t::s, simd_load_stat_p(), statement_ordering, and statements_conflict_relaxed_p().

Referenced by recurse_statements_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

do_remove_preference()

static bool do_remove_preference ( cell  c )

static

helper to transform preferences in references

Definition at line 76 of file delay.c.

                                        {
    if(cell_preference_p(c)) {
        reference r = copy_reference(
                preference_reference(cell_preference(c))
                );
        free_preference(cell_preference(c));
        cell_tag(c)=is_cell_reference;
        cell_reference(c)=r;
    }
    return true;
}

References cell_preference, cell_preference_p, cell_reference, cell_tag, copy_reference(), free_preference(), is_cell_reference, and preference_reference.

Referenced by remove_preferences().

Here is the call graph for this function:

Here is the caller graph for this function:

do_remove_redundant_communications_in_anyloop()

static bool do_remove_redundant_communications_in_anyloop ( statement  parent, statement  body  )

static

skip declarations

look for heading dma statements

look for trailing dma statements

insert them around the loop

flatten_code if needed

and remove them from the alternate list

Definition at line 851 of file delay.c.

                                                                                            {
    bool need_flatten=false;
    if(statement_block_p(body)) {
        list b = statement_block(body);
        list iordered=b;
        /* skip declarations */
        while(!ENDP(iordered) &&
                declaration_statement_p(STATEMENT(CAR(iordered))) ) POP(iordered);
        bool skipped_declarations= (iordered != b);
        list reversed = gen_nreverse(gen_copy_seq(iordered));
        /* look for heading dma statements */
        iordered=gen_copy_seq(iordered); // to be consistent with `reversed' allocation
        select_independent_dmas(&iordered, parent);
        /* look for trailing dma statements */
        select_independent_dmas(&reversed, parent);
 
        bool did_something=false;
        for(list oter=iordered;!ENDP(oter);POP(oter)) {
            statement os = STATEMENT(CAR(oter));
            FOREACH(STATEMENT,rs,reversed) {
                if(simd_dma_stat_p(os) &&
                        simd_dma_stat_p(rs) &&
                        dmas_invert_p(os,rs)) {
                    gen_remove_once(&b,rs);
                    gen_remove_once(&b,os);
                    /* insert them around the loop */
                    insert_statement(parent,os,true);
                    insert_statement(parent,rs,false);
                    /* flatten_code if needed */
                    set re = get_referenced_entities(os);
                    set de = set_make(set_pointer);
                    set_assign_list(de,statement_declarations(body));
                    if(set_intersection_p(de,re)) need_flatten = true;
                    set_free(de);set_free(re);
                    /* and remove them from the alternate list */
                    gen_remove_once(&b,rs);
                    gen_remove_once(&reversed,os);
                    did_something=true;
                    break;
                }
            }
        }
        gen_free_list(iordered);
        gen_free_list(reversed);
        if(did_something && skipped_declarations)
            need_flatten=true;
        sequence_statements(statement_sequence(body)) = b;
    }
    return need_flatten;
}

References CAR, declaration_statement_p(), dmas_invert_p(), ENDP, FOREACH, gen_copy_seq(), gen_free_list(), gen_nreverse(), gen_remove_once(), get_referenced_entities(), insert_statement(), POP, select_independent_dmas(), sequence_statements, set_assign_list(), set_free(), set_intersection_p(), set_make(), set_pointer, simd_dma_stat_p(), STATEMENT, statement_block(), statement_block_p, statement_declarations, and statement_sequence().

Referenced by do_remove_redundant_communications_in_forloop(), do_remove_redundant_communications_in_loop(), and do_remove_redundant_communications_in_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

do_remove_redundant_communications_in_forloop()

static void do_remove_redundant_communications_in_forloop ( forloop  l, bool *  need_flatten  )

static

Definition at line 910 of file delay.c.

                                                                                          {
    *need_flatten|=do_remove_redundant_communications_in_anyloop((statement)gen_get_ancestor(statement_domain,l),forloop_body(l));
}

References do_remove_redundant_communications_in_anyloop(), forloop_body, gen_get_ancestor(), and statement_domain.

Referenced by remove_redundant_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

do_remove_redundant_communications_in_loop()

static void do_remove_redundant_communications_in_loop ( loop  l, bool *  need_flatten  )

static

Definition at line 902 of file delay.c.

                                                                                    {
    *need_flatten|=do_remove_redundant_communications_in_anyloop((statement)gen_get_ancestor(statement_domain,l),loop_body(l));
}

References do_remove_redundant_communications_in_anyloop(), gen_get_ancestor(), loop_body, and statement_domain.

Referenced by remove_redundant_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

do_remove_redundant_communications_in_sequence()

static void do_remove_redundant_communications_in_sequence ( sequence  s, bool *  need_flatten  )

static

remove the second statements from the original sequence if we have load ; store , the store is useless and the load will be removed by a used_def_elim phase if we have store ; load, it 's the same

Definition at line 803 of file delay.c.

                                                                                          {
  pips_assert("true",need_flatten==need_flatten );
    list ts = gen_copy_seq(sequence_statements(s));
    statement prev = statement_undefined;
    FOREACH(STATEMENT,st,ts) {
        if(simd_dma_stat_p(st)) {
            if(!statement_undefined_p(prev)) { // do they annihilate each other ?
                if(dmas_invert_p(st,prev)) {
                /* remove the second statements from the original sequence
                 * if we have load ; store , the store is useless
                 * and the load will be removed by a used_def_elim phase
                 * if we have store ; load, it 's the same
                 */
                //    gen_remove_once(&sequence_statements(s),prev);
                    gen_remove_once(&sequence_statements(s),st);
                }
                else
                    prev=st;
                prev=statement_undefined;
            }
            else
                prev=st;
        }
        else
            prev=statement_undefined;
    }
    gen_free_list(ts);
}

References dmas_invert_p(), FOREACH, gen_copy_seq(), gen_free_list(), gen_remove_once(), pips_assert, sequence_statements, simd_dma_stat_p(), STATEMENT, statement_undefined, and statement_undefined_p.

Referenced by remove_redundant_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

do_remove_redundant_communications_in_whileloop()

static void do_remove_redundant_communications_in_whileloop ( whileloop  l, bool *  need_flatten  )

static

Definition at line 906 of file delay.c.

                                                                                              {
    *need_flatten|=do_remove_redundant_communications_in_anyloop((statement)gen_get_ancestor(statement_domain,l),whileloop_body(l));
}

References do_remove_redundant_communications_in_anyloop(), gen_get_ancestor(), statement_domain, and whileloop_body.

Referenced by remove_redundant_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_statement_in_block()

static void insert_statement_in_block ( statement  s, statement  inserted, bool  before, list *  block  )

static

Definition at line 292 of file delay.c.

                                                                                                 {
    if(statement_block_p(s))
        insert_statement(s,inserted,before);
    else {
        create_block_if_needed(&s,&block);
        if(before)
            *block=gen_insert_before(inserted,s,*block);
        else
            gen_insert_after(inserted,s,*block);
    }
}

References create_block_if_needed(), gen_insert_after(), gen_insert_before(), insert_statement(), and statement_block_p.

Referenced by delay_communications_anyloop(), delay_communications_statement(), delay_communications_test(), and manage_conflicts().

Here is the call graph for this function:

Here is the caller graph for this function:

manage_conflicts()

static void manage_conflicts ( statement  s, context *  c, bool  before, list *  block  )

static

check conflicts with current stats

Definition at line 304 of file delay.c.

                                                                               {
  /* check conflicts with current stats */
  list tstats = gen_copy_seq(c->stats);
  FOREACH(STATEMENT,st,tstats) {
    if(statements_conflict_p(s,st)) {
      insert_statement_in_block(s,st,before,block);
      gen_remove_once(&c->stats,st);
    }
  }
  gen_free_list(tstats);
}

References FOREACH, gen_copy_seq(), gen_free_list(), gen_remove_once(), insert_statement_in_block(), STATEMENT, statements_conflict_p(), and context::stats.

Referenced by delay_communications_anyloop(), delay_communications_call(), and delay_communications_test().

Here is the call graph for this function:

Here is the caller graph for this function:

promote_local_entities()

static void promote_local_entities ( statement  s, entity  caller, statement  caller_statement  )

static

if some local variables are going to be accessed inter procedurally, promote them to global variables

Definition at line 502 of file delay.c.

                                                                                           {
  pips_assert("true", caller==caller && caller_statement==caller_statement);
  set re = get_referenced_entities(s);
  list le = NIL;
  SET_FOREACH(entity,e,re) {
    if(local_entity_of_module_p(e,get_current_module_entity()) &&
        !formal_parameter_p(e) ) {
      le=CONS(ENTITY,e,le);
    }
  }
  set_free(re);
  gen_sort_list(le,(gen_cmp_func_t)compare_entities);//ensure determinism
  FOREACH(ENTITY,e,le) {
    entity new = entity_undefined;
    if(entity_scalar_p(e)) {
      new= make_new_scalar_variable_with_prefix(
          entity_user_name(e),
          module_entity_to_compilation_unit_entity(get_current_module_entity()),
          copy_basic(entity_basic(e))
          );
      
    }
    else {
      pips_assert("not scalars -> array\n",entity_array_p(e));
      new= make_new_array_variable_with_prefix(
          entity_user_name(e),
          module_entity_to_compilation_unit_entity(get_current_module_entity()),
          copy_basic(entity_basic(e)),
          gen_full_copy_list(variable_dimensions(type_variable(entity_type(e))))
          );
    }
    if(!value_unknown_p(entity_initial(e)))
      statement_split_initializations(get_current_module_statement());
    RemoveLocalEntityFromDeclarations(e,get_current_module_entity(),get_current_module_statement());
    AddEntityToModuleCompilationUnit(new,get_current_module_entity());
    AddEntityToModuleCompilationUnit(new,module_entity_to_compilation_unit_entity(get_current_module_entity()));
    replace_entity(get_current_module_statement(),e,new);
  }
}

References AddEntityToModuleCompilationUnit(), compare_entities(), CONS, copy_basic(), ENTITY, entity_array_p(), entity_basic(), entity_initial, entity_scalar_p(), entity_type, entity_undefined, entity_user_name(), FOREACH, formal_parameter_p(), gen_full_copy_list(), gen_sort_list(), get_current_module_entity(), get_current_module_statement(), get_referenced_entities(), local_entity_of_module_p(), make_new_array_variable_with_prefix(), make_new_scalar_variable_with_prefix(), module_entity_to_compilation_unit_entity(), NIL, pips_assert, RemoveLocalEntityFromDeclarations(), replace_entity(), SET_FOREACH, set_free(), statement_split_initializations(), type_variable, value_unknown_p, and variable_dimensions.

Referenced by do_delay_communications_interprocedurally().

Here is the call graph for this function:

Here is the caller graph for this function:

recurse_statements_conflict_p()

static bool recurse_statements_conflict_p ( statement  s, statement  in  )

static

checks if there is a conflict between s and any statement in in

Definition at line 247 of file delay.c.

                                                                     {
    conflict_t c = { s, false };
    gen_context_recurse(in, &c, statement_domain, gen_true2, do_recurse_statements_conflict_p);
    return c.conflict;
}

References conflict_t::conflict, do_recurse_statements_conflict_p(), gen_context_recurse, gen_true2(), and statement_domain.

Referenced by delay_communications_anyloop().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_preferences()

void remove_preferences

(

void *

obj

)

entry point to transform preferences in references

delay.c

Parameters

obj

bj

Definition at line 89 of file delay.c.

                                    {
    gen_recurse(obj, cell_domain, do_remove_preference, gen_null);
}

References cell_domain, do_remove_preference(), gen_null(), and gen_recurse.

Referenced by delay_communications(), delay_load_communications(), delay_store_communications(), loop_annotate(), and simdizer().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_redundant_communications()

static bool remove_redundant_communications ( statement  s )

static

Definition at line 914 of file delay.c.

                                                         {
    bool need_flatten=false;
    gen_context_multi_recurse(s,&need_flatten,
            sequence_domain,gen_true,do_remove_redundant_communications_in_sequence,
            loop_domain,gen_true,do_remove_redundant_communications_in_loop,
            whileloop_domain,gen_true,do_remove_redundant_communications_in_whileloop,
            forloop_domain,gen_true,do_remove_redundant_communications_in_forloop,
            NULL);
    return need_flatten;
}

References do_remove_redundant_communications_in_forloop(), do_remove_redundant_communications_in_loop(), do_remove_redundant_communications_in_sequence(), do_remove_redundant_communications_in_whileloop(), forloop_domain, gen_context_multi_recurse(), gen_true(), loop_domain, sequence_domain, and whileloop_domain.

Referenced by delay_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

select_independent_dmas()

static void select_independent_dmas ( list *  stats, statement  parent  )

static

Definition at line 832 of file delay.c.

                                                                    {
    list rtmp = NIL;
    FOREACH(STATEMENT,st,*stats)
        if(simd_dma_stat_p(st)) {
            bool conflict = false;
            FOREACH(STATEMENT,st2,rtmp) {
                if((conflict=statements_conflict_p(st,st2)))
                    break;
            }
            conflict|=statements_conflict_p(st,parent);
            if(conflict) break;
            rtmp=CONS(STATEMENT,st,rtmp);
        }
        else
            break;
    gen_free_list(*stats);
    *stats=rtmp;
}

References CONS, FOREACH, gen_free_list(), NIL, simd_dma_stat_p(), STATEMENT, and statements_conflict_p().

Referenced by do_remove_redundant_communications_in_anyloop().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_dma_stat_p()

bool simd_dma_stat_p

(

statement

stat

)

This function returns true if the statement is a simd loadsave statement.

Parameters

stat

tat

Definition at line 127 of file delay.c.

{
    return simd_load_stat_p(stat) || simd_store_stat_p(stat);
}

References simd_load_stat_p(), and simd_store_stat_p().

Referenced by dmas_invert_p(), do_remove_redundant_communications_in_anyloop(), do_remove_redundant_communications_in_sequence(), select_independent_dmas(), simd_stat_p(), and simd_trace_call().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_load_call_p()

static bool simd_load_call_p ( call  c )

static

Definition at line 95 of file delay.c.

                                     {
  const char* funcName = entity_local_name(call_function(c));
  const char* simd= get_string_property("ACCEL_LOAD");
  return    same_stringn_p(funcName, simd, strlen(simd));
}

References call_function, entity_local_name(), get_string_property(), and same_stringn_p.

Referenced by simd_load_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_load_stat_p()

bool simd_load_stat_p

(

statement

stat

)

Parameters

stat

tat

Definition at line 111 of file delay.c.

{
  return statement_call_p(stat) && simd_load_call_p(statement_call(stat));
}

References simd_load_call_p(), statement_call(), and statement_call_p().

Referenced by delay_communications_call(), do_recurse_statements_conflict_p(), and simd_dma_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_stat_p()

bool simd_stat_p

(

statement

stat

)

This function returns true if the statement is a simd statement.

Parameters

stat

tat

Definition at line 135 of file delay.c.

{
    return simd_dma_stat_p(stat) || simd_work_stat_p(stat);
}

References simd_dma_stat_p(), and simd_work_stat_p().

Here is the call graph for this function:

simd_store_call_p()

static bool simd_store_call_p ( call  c )

static

Definition at line 105 of file delay.c.

                                      {
  const char* funcName = entity_local_name(call_function(c));
  const char* simd= get_string_property("ACCEL_STORE");
  return    same_stringn_p(funcName, simd, strlen(simd));
}

References call_function, entity_local_name(), get_string_property(), and same_stringn_p.

Referenced by simd_store_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_store_stat_p()

bool simd_store_stat_p

(

statement

stat

)

Parameters

stat

tat

Definition at line 119 of file delay.c.

{
  return statement_call_p(stat) && simd_store_call_p(statement_call(stat));
}

References simd_store_call_p(), statement_call(), and statement_call_p().

Referenced by delay_communications_call(), simd_dma_stat_p(), statements_conflict_p(), and statements_conflict_relaxed_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_work_call_p()

static bool simd_work_call_p ( call  c )

static

Definition at line 100 of file delay.c.

                                     {
  const char* funcName = entity_local_name(call_function(c));
  const char* simd= get_string_property("ACCEL_WORK");
  return    same_stringn_p(funcName, simd, strlen(simd));
}

References call_function, entity_local_name(), get_string_property(), and same_stringn_p.

Referenced by simd_work_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_work_stat_p()

bool simd_work_stat_p

(

statement

stat

)

Parameters

stat

tat

Definition at line 115 of file delay.c.

{
  return statement_call_p(stat) && simd_work_call_p(statement_call(stat));
}

References simd_work_call_p(), statement_call(), and statement_call_p().

Referenced by simd_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

statements_conflict_p()

static bool statements_conflict_p ( statement  s0, statement  s1  )

static

checks if there exist a conflict between s0 and s1 according to the dependency graph

in intra procedural, a store always conflicts with a return

special hook for loop statements: dependency on the index are not well generated

Definition at line 161 of file delay.c.

                                                              {
    /* in intra procedural, a store always conflicts with a return */
    if(!delay_communications_interprocedurally_p &&
            ( simd_store_stat_p(s0) || simd_store_stat_p(s1) ) &&
            ( return_statement_p(s0) || return_statement_p(s1) ) )
        return true;
 
    /* special hook for loop statements: dependency on the index are not well generated */
    if(statement_loop_p(s1)) {
        entity index = loop_index(statement_loop(s1));
        set re = get_referenced_entities(s0);
        bool conflict = set_belong_p(re,index);
        set_free(re);
        return conflict;
    }
 
    FOREACH(VERTEX,v,graph_vertices(dependence_graph)) {
        statement s = vertex_to_statement(v);
        if(statement_ordering(s) == statement_ordering(s0) || statement_ordering(s) == statement_ordering(s1)) {
            intptr_t expected = statement_ordering(s) == statement_ordering(s0) ? statement_ordering(s1) : statement_ordering(s0);
            FOREACH(SUCCESSOR,su,vertex_successors(v)) {
                if(statement_ordering(vertex_to_statement(successor_vertex(su))) == expected ) {
                    return true;
                }
            }
        }
    }
  return false;
}

References delay_communications_interprocedurally_p, dependence_graph, FOREACH, get_referenced_entities(), graph_vertices, intptr_t, loop_index, return_statement_p(), s1, set_belong_p(), set_free(), simd_store_stat_p(), statement_loop(), statement_loop_p(), statement_ordering, SUCCESSOR, successor_vertex, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by delay_communications_anyloop(), manage_conflicts(), and select_independent_dmas().

Here is the call graph for this function:

Here is the caller graph for this function:

statements_conflict_relaxed_p()

static bool statements_conflict_relaxed_p ( statement  s0, statement  s1, bool  load_p  )

static

same as statements_conflict_p but W-* conflicts are ignored if load_p, R-* conflicts are ignored if not load_p

in intra procedural, a store always conflicts with a return

Definition at line 192 of file delay.c.

                                                                                   {
    /* in intra procedural, a store always conflicts with a return */
    if(!delay_communications_interprocedurally_p &&
            ( simd_store_stat_p(s0) || simd_store_stat_p(s1) ) &&
            ( return_statement_p(s0) || return_statement_p(s1) ) )
        return true;
 
    FOREACH(VERTEX,v,graph_vertices(dependence_graph)) {
        statement s = vertex_to_statement(v);
        if(statement_ordering(s) == statement_ordering(s0) ) {
            intptr_t expected = statement_ordering(s1) ;
            FOREACH(SUCCESSOR,su,vertex_successors(v)) {
                if(statement_ordering(vertex_to_statement(successor_vertex(su))) == expected ) {
                    FOREACH(CONFLICT,c,dg_arc_label_conflicts(successor_arc_label(su))) {
                        if( (load_p && !effect_write_p(conflict_source(c))) ||
                                (!load_p && !effect_read_p(conflict_source(c))) )
                            return true;
                    }
                }
            }
        }
    }
  return false;
}

References CONFLICT, conflict_source, delay_communications_interprocedurally_p, dependence_graph, dg_arc_label_conflicts, effect_read_p, effect_write_p, FOREACH, graph_vertices, intptr_t, return_statement_p(), s1, simd_store_stat_p(), statement_ordering, SUCCESSOR, successor_arc_label, successor_vertex, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by do_recurse_statements_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_arguments()

static statement translate_arguments ( call  ca, statement  s  )

static

Definition at line 484 of file delay.c.

                                                           {
  statement new = copy_statement(s);
  list fp = module_formal_parameters(get_current_module_entity());
  pips_assert("as many parameters as formal arguments\n",gen_length(call_arguments(ca)) == gen_length(fp));
  for(list aiter = call_arguments(ca), piter=fp;
      !ENDP(aiter);
      POP(aiter),POP(piter)) {
    expression arg = EXPRESSION(CAR(aiter));
    entity fe = ENTITY(CAR(piter));
    replace_entity_by_expression(new,fe,arg);// this perform the formal / effective parameter substitution
  }
  gen_free_list(fp);
  return new;
}

References call_arguments, CAR, copy_statement(), ENDP, ENTITY, EXPRESSION, gen_free_list(), gen_length(), get_current_module_entity(), module_formal_parameters(), pips_assert, POP, and replace_entity_by_expression().

Referenced by do_delay_communications_interprocedurally().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

__delay_communications_patch_properties

bool __delay_communications_patch_properties

static

Definition at line 588 of file delay.c.

Referenced by delay_communications_init(), and delay_communications_reset().

delay_communications_interprocedurally_p

bool delay_communications_interprocedurally_p

static

Definition at line 73 of file delay.c.

Referenced by delay_communications_init(), delay_communications_inter(), delay_communications_intra(), delay_communications_reset(), delay_load_communications(), delay_load_communications_inter(), delay_load_communications_intra(), delay_store_communications(), delay_store_communications_inter(), delay_store_communications_intra(), statements_conflict_p(), and statements_conflict_relaxed_p().

dependence_graph

graph dependence_graph =graph_undefined

static

Definition at line 93 of file delay.c.

Referenced by delay_communications(), delay_communications_init(), delay_communications_reset(), delay_load_communications(), delay_store_communications(), dma_statements_conflict_p(), flint_initialize_statement_def_use_variables(), flint_uninitialized_variables(), flinter(), init_statement_equivalence_table(), reduction_detection(), reduction_propagation(), redundant_load_store_elimination(), simdize_simple_statements(), statements_conflict_p(), and statements_conflict_relaxed_p().