analyse.c File Reference

#include "defines-local.h"
#include "workspace-util.h"
#include "prettyprint.h"
#include "preprocessor.h"
#include "transformer.h"
#include "semantics.h"
#include "dg.h"
#include "graph.h"
#include "ricedg.h"
#include "bootstrap.h"
#include "STEP_RT_intrinsic.h"
#include "STEP_RT_bootstrap.h"

Include dependency graph for analyse.c:

Go to the source code of this file.

Typedefs
typedef dg_arc_label	arc_label
typedef dg_vertex_label	vertex_label

Functions
static bool	step_statement_path_build (statement stmt, list *sp_current)
static void	step_statement_path_unbuild (statement stmt, list *sp_current)
static void	step_statement_path_init (statement body)
static void	step_statement_path_finalize (void)
static list	step_statement_path_get (statement stmt)
static statement	step_statement_path_first_directive_statement (statement stmt)
static list	step_statement_path_factorise (statement s1, statement s2, list *suffix_sp1, list *suffix_sp2)
bool	step_interlaced_p (region reg)
bool	step_partial_p (region reg)
bool	step_analysed_module_p (const char *module_name)
void	load_step_comm ()
void	reset_step_comm ()
void	store_step_comm ()
static void	step_add_point_into_effect_path (effect new_eff, entity module, statement stmt, effect previous_eff)
static void	step_print_effect_path (list path)
static list	step_get_effect_path (effect start_eff)
static effect	get_directive_statement_region (effect reg)
static void	step_set_step_partial (effect send_region, bool partial_p)
static void	step_set_communication_type_full (effect send_region)
static void	step_set_communication_type_partial (effect send_region)
void	debug_print_effects_list (list l, string txt)
bool	step_analyse_init (const string module_name)
region	rectangularization_region (region reg)
static list	create_step_regions (statement stmt, list regions_l, enum action_utype action_tag)
static void	step_init_effect_path (entity module, statement stmt, list regions_l)
static bool	anymodule_anywhere_region_p (list regions_l)
static list	compute_send_regions (list write_l, list out_l, statement stmt)
static list	compute_recv_regions (list send_l, list in_l, statement stmt)
static bool	interlaced_basic_workchunk_regions_p (region reg, list index_l)
static list	step_send_regions_list_load (statement s)
static void	step_send_regions_list_store (statement s, list l_regions)
static void	step_send_regions_list_update (statement s, list l_regions)
static void	step_send_regions_list_add (statement stmt, list l_regions)
static list	step_recv_regions_list_load (statement s)
static void	step_recv_regions_list_store (statement s, list l_regions)
static void	step_recv_regions_list_update (statement s, list l_regions)
static void	step_recv_regions_list_add (statement stmt, list l_regions)
static void	step_print_directives_regions (step_directive d, list send_l, list recv_l)
static list	summarize_and_map_step_regions (list effect_l, entity module, statement body)
static void	step_summarize_and_map_step_regions (statement stmt)
static void	step_initialize_step_partial (list send_l)
static void	step_compute_step_interlaced (list send_l, step_directive d)
static bool	compute_directive_regions (step_directive drt)
static list	step_translate_and_map (statement stmt, list effects_called_l)
static bool	step_translate_and_map_step_regions (statement stmt)
static bool	compute_SENDRECV_regions (statement stmt, bool *exist_regions_p)
static bool	concerned_entity_p (effect eff, list regions)
static void	step_get_comparable_effects (list eff_list, effect eff, set *effects_set)
static void	step_compute_CHAINS_DG_remove_summary_regions (successor su, list source_send_l, list sink_recv_l, set *remove_from_summary_send, set *remove_from_summary_recv)
static void	step_compute_CHAINS_DG_SENDRECV_regions (statement s1, statement s2, list *s1_send_l, list *s2_recv_l)
static void	step_analyse_CHAINS_DG (const char *module_name, set *remove_from_summary_send, set *remove_from_summary_recv)
static void	update_SUMMARY_SENDRECV_regions (set remove_from_summary_regions, list tmp_summary_regions_l, list *final_summary_regions_l)
static void	step_update_SUMMARY_SENDRECV_regions (set remove_from_summary_send, set remove_from_summary_recv, list *full_send_l, list *partial_send_l)
static void	step_update_comm (list full_send_l, list partial_send_l)
static bool	step_compute_SENDRECV_regions (entity module, statement body)
bool	step_analyse (const char *module_name)

Variables
static hash_table	step_statement_path = hash_table_undefined
	The step_analyse phase computes three main resources: More...

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Definition at line 13 of file analyse.c.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 14 of file analyse.c.

Function Documentation

anymodule_anywhere_region_p()

static bool anymodule_anywhere_region_p ( list  regions_l )

static

Definition at line 479 of file analyse.c.

{
  bool is_anymodule_anywhere = false;
 
  FOREACH(REGION, reg, regions_l)
    {
      if (anywhere_effect_p(reg))
        {
          is_anymodule_anywhere = true;
          break;
        }
    }
 
  return is_anymodule_anywhere;
}

References anywhere_effect_p(), FOREACH, and REGION.

Referenced by compute_directive_regions(), compute_recv_regions(), and compute_send_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_directive_regions()

static bool compute_directive_regions ( step_directive  drt )

static

TODO ajouter un test si tout est vide.

Store SEND/RECV directive statement regions

Initialization of step_effect_path for each send/recv regions

Initialization of step_interlaced and step_partial for each send region

Definition at line 888 of file analyse.c.

{
  entity module = get_current_module_entity();
 
  pips_debug(1,"Begin\n");
 
  statement directive_stmt = step_directive_block(drt);
  statement stmt_basic_workchunk = step_directive_basic_workchunk(drt);
  assert(!statement_undefined_p(stmt_basic_workchunk));
 
  ifdebug(1)
    {
      step_directive_print(drt);
    }
 
  list rw_l = load_rw_effects_list(stmt_basic_workchunk);
  list write_l = regions_write_regions(rw_l);
  list in_l = load_in_effects_list(stmt_basic_workchunk);
  list out_l = load_out_effects_list(stmt_basic_workchunk);
 
  /* TODO ajouter un test si tout est vide. */
 
  list send_l = compute_send_regions(write_l, out_l, directive_stmt);
  list recv_l = compute_recv_regions(send_l, in_l, directive_stmt);
 
 
  /* Store SEND/RECV directive statement regions */
  step_send_regions_list_store(directive_stmt, send_l);
  step_recv_regions_list_store(directive_stmt, recv_l);
 
#ifdef FRED
  pips_assert("ANYMODULE ANYWHERE SEND regions", !anymodule_anywhere_region_p(send_l));
  pips_assert("ANYMODULE ANYWHERE RECV regions", !anymodule_anywhere_region_p(recv_l));
#endif
 
  /* Initialization of step_effect_path for each send/recv regions */
  step_init_effect_path(module, directive_stmt, send_l);
  step_init_effect_path(module, directive_stmt, recv_l);
 
  /* Initialization of step_interlaced and step_partial for each send region */
  step_initialize_step_partial(send_l);
  step_compute_step_interlaced(send_l, drt);
 
  ifdebug(3)
    {
      step_print_directives_regions(drt, send_l, recv_l);
    }
  pips_debug(1,"End\n");
  return !(ENDP(recv_l) && ENDP(send_l));
}

References anymodule_anywhere_region_p(), assert, compute_recv_regions(), compute_send_regions(), ENDP, get_current_module_entity(), ifdebug, load_in_effects_list(), load_out_effects_list(), load_rw_effects_list(), module, pips_assert, pips_debug, regions_write_regions(), statement_undefined_p, step_compute_step_interlaced(), step_directive_basic_workchunk(), step_directive_block, step_directive_print(), step_init_effect_path(), step_initialize_step_partial(), step_print_directives_regions(), step_recv_regions_list_store(), and step_send_regions_list_store().

Referenced by compute_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_recv_regions()

static list compute_recv_regions ( list  send_l, list  in_l, statement  stmt  )

static

ANYMODULE ANYWHERE recv regions should cause FULL communications thus ANYMODULE ANYWHERE recv regions are removed from recv regions.

Definition at line 555 of file analyse.c.

{
  pips_debug(2,"begin\n");
  list recv_final = NIL;
  list send_may_l = NIL;
  list recv_l;
 
  /*
     RECV = IN Union SEND-MAY
 
     Generally, for a given construct, SEND is not sur-approximated
     then SEND-MAY is empty thus
 
     RECV = IN
 
     But, for a given construct, when SEND is sur-approximated (i.e. SEND
     MAY), then the communication is interlaced and a diff is
     necessary at the end to determine what data were updated.
 
     Thus data in the sur-approximation must have a correct value even
     if they are not read (for the diff).
 
     Thus when SEND is sur-approximated: RECV = IN Union SEND-MAY
  */
 
  FOREACH(REGION, reg, send_l)
    {
      if (region_may_p(reg))
        send_may_l = CONS(REGION, region_dup(reg), send_may_l);
    }
 
  ifdebug(2)
    {
      debug_print_effects_list(send_may_l, "SEND may :");
      debug_print_effects_list(in_l, "IN :");
    }
 
  recv_l = RegionsMustUnion(regions_dup(in_l), regions_dup(send_may_l), r_w_combinable_p);
  gen_full_free_list(send_may_l);
 
  if (anymodule_anywhere_region_p(recv_l))
    {
      /* ANYMODULE ANYWHERE recv regions should cause FULL communications
         thus ANYMODULE ANYWHERE recv regions are removed from recv regions.
       */
      pips_debug(2,"drop ANYMODULE ANYWHERE RECV regions\n");
      recv_final = NIL;
      gen_full_free_list(recv_l);
    }
  else
    {
      recv_final = create_step_regions(stmt, recv_l, is_action_read);
      gen_full_free_list(recv_l);
    }
 
  ifdebug(2)
    debug_print_effects_list(recv_final, "RECV final :");
 
  pips_debug(2,"end\n");
  return recv_final;
}

References anymodule_anywhere_region_p(), CONS, create_step_regions(), debug_print_effects_list(), FOREACH, gen_full_free_list(), ifdebug, is_action_read, NIL, pips_debug, r_w_combinable_p(), REGION, region_dup(), region_may_p, regions_dup(), and RegionsMustUnion().

Referenced by compute_directive_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_send_regions()

static list compute_send_regions ( list  write_l, list  out_l, statement  stmt  )

static

ANYMODULE ANYWHERE send regions are a big problem! FIXME.

Definition at line 495 of file analyse.c.

{
  pips_debug(2,"begin\n");
  list send_final = NIL;
  list write_tmp_l = regions_dup(write_l);
  list out_tmp_l = regions_dup(out_l);
 
  /*
     SEND = OUT Inter WRITE
 
     Computation of the approximation (EXACT or MAY)
 
     1) OUT-MAY Inter WRITE-MAY -> SEND-MAY
     2) OUT-EXACT Inter WRITE-MAY -> SEND-MAY
     3) OUT-EXACT Inter WRITE-EXACT -> SEND-EXACT
     4) OUT-MAY Inter WRITE-EXACT -> SEND-MAY
 
     Case 4 is a problem, we want OUT-MAY Inter WRITE-EXACT --> SEND-*EXACT*.
 
     Generally the approximation of the SEND region should be the
     approximation of the WRITE region because OUT should be used only
     to reduce region communication. Thus we artificially transform
     the out approximation as EXACT so that the MAY approximation does
     not impact the SEND approximation.
  */
 
  FOREACH(REGION, reg, out_tmp_l)
    {
      free_approximation(region_approximation(reg));
      region_approximation(reg)=make_approximation_exact();
    }
 
  ifdebug(2)
    {
      debug_print_effects_list(out_tmp_l, "OUT :");
      debug_print_effects_list(write_tmp_l, "WRITE :");
    }
 
  list send_l = RegionsIntersection(out_tmp_l, write_tmp_l, w_w_combinable_p);
 
  if (anymodule_anywhere_region_p(send_l))
    {
      /* ANYMODULE ANYWHERE send regions are a big problem! FIXME.
      */
 
      STEP_DEBUG_STATEMENT(0, "ANYWHERE effect on stmt", stmt);
      pips_debug(0, "end stmt\n");
      pips_user_warning("ANYWHERE effect in SEND regions\n");
    }
 
  send_final = create_step_regions(stmt, send_l, is_action_write);
  gen_full_free_list(send_l);
 
  ifdebug(2)
    debug_print_effects_list(send_final, "SEND final :");
 
  pips_debug(2,"end\n");
  return send_final;
}

References anymodule_anywhere_region_p(), create_step_regions(), debug_print_effects_list(), FOREACH, free_approximation(), gen_full_free_list(), ifdebug, is_action_write, make_approximation_exact(), NIL, pips_debug, pips_user_warning, REGION, region_approximation, regions_dup(), RegionsIntersection(), STEP_DEBUG_STATEMENT, and w_w_combinable_p().

Referenced by compute_directive_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_SENDRECV_regions()

static bool compute_SENDRECV_regions ( statement  stmt, bool *  exist_regions_p  )

static

default: SEND/RECV regions are summarized at the body level of the current module. This will be modified later using the DG

When module call, compute translated SEND and RECV regions

Note: all entities present in the field call_function are not a module ie it could also be a numerical constant, an intrinsics...

default: SEND/RECV regions are summarized at the body level of the current module. This will be modified later using the DG

Definition at line 1078 of file analyse.c.

{
  assert(!statement_undefined_p(stmt));
 
  STEP_DEBUG_STATEMENT(2, "begin on stmt", stmt);
 
  if(step_directives_bound_p(stmt))
    {
      step_directive drt = step_directives_load(stmt);
      assert(stmt==step_directive_block(drt));
      *exist_regions_p |= compute_directive_regions(drt);
 
      /* default: SEND/RECV regions are summarized at the body level of the current module.
         This will be modified later using the DG
       */
      step_summarize_and_map_step_regions(stmt);
    }
  else
    {
      /* When module call, compute translated SEND and RECV regions
 
         Note: all entities present in the field call_function are not
         a module ie it could also be a numerical constant, an
         intrinsics...
       */
      if (statement_call_p(stmt) && entity_module_p(call_function(statement_call(stmt))))
        {
          *exist_regions_p |= step_translate_and_map_step_regions(stmt);
          /* default: SEND/RECV regions are summarized at the body level of the current module.
             This will be modified later using the DG
          */
          step_summarize_and_map_step_regions(stmt);
        }
      else
        pips_debug(2, "no STEP region to compute\n");
    }
 
  pips_debug(2, "end\n");
  return true;
}

References assert, call_function, compute_directive_regions(), entity_module_p(), pips_debug, statement_call(), statement_call_p(), statement_undefined_p, STEP_DEBUG_STATEMENT, step_directive_block, step_directives_bound_p(), step_directives_load(), step_summarize_and_map_step_regions(), and step_translate_and_map_step_regions().

Referenced by step_compute_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

concerned_entity_p()

static bool concerned_entity_p ( effect  eff, list  regions  )

static

Definition at line 1119 of file analyse.c.

{
  pips_debug(4, "begin\n");
  FOREACH(REGION, reg, regions)
    {
      pips_debug(5, "\n eff %s regions %s\n", text_to_string(text_region(eff)), text_to_string(text_region(reg)));
      if (effect_comparable_p(eff, reg))
        {
          pips_debug(4, "end TRUE\n");
          return true;
        }
    }
  pips_debug(4, "end FALSE\n");
  return false;
}

References effect_comparable_p(), FOREACH, pips_debug, REGION, text_region(), and text_to_string().

Referenced by step_compute_CHAINS_DG_remove_summary_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

create_step_regions()

static list create_step_regions ( statement  stmt, list  regions_l, enum action_utype  action_tag  )

static

remove omp private from send and recv regions

Remove precondition contrainte

Definition at line 406 of file analyse.c.

{
  list regions_final = NIL;
 
  pips_debug(2,"begin\n");
 
  FOREACH(REGION, reg, regions_l)
    {
      if (step_private_p(stmt,region_entity(reg)))
        {
          /* remove omp private from send and recv regions */
          pips_debug(2,"drop private entity %s\n", entity_name(region_entity(reg)));
          continue;
        }
      if (io_effect_p(reg) || std_file_effect_p(reg))
        {
          pips_debug(2,"drop I/O effect on %s\n", entity_name(region_entity(reg)));
          continue;
        }
      if (FILE_star_effect_reference_p(region_any_reference(reg)))
        {
          pips_debug(2,"drop effect on FILE * : %s\n", entity_name(region_entity(reg)));
          continue;
        }
      if (entity_scalar_p(region_entity(reg)))
        {
          pips_debug(2,"drop scalar region %s\n", entity_name(region_entity(reg)));
          continue;
        }
 
      /* Remove precondition contrainte */
      transformer stmt_precondition = load_statement_precondition(stmt);
      Psysteme sc = predicate_system(transformer_relation(stmt_precondition));
      region_system(reg) = extract_nredund_subsystem(region_system(reg), sc);
 
      region r = region_dup(rectangularization_region(reg));
 
      free_action(region_action(r));
      switch (action_tag)
        {
        case is_action_read:
          region_action(r) = make_action_read_memory();
          break;
        case is_action_write:
          region_action(r) = make_action_write_memory();
          break;
        default:
          pips_assert("unknown action_tag", 0);
        }
 
      regions_final = CONS(REGION, r, regions_final);
    }
  gen_sort_list(regions_final, (gen_cmp_func_t)compare_effect_reference);
 
  pips_debug(2,"end\n");
  return regions_final;
}

References action_tag, compare_effect_reference(), CONS, entity_name, entity_scalar_p(), extract_nredund_subsystem(), FILE_star_effect_reference_p(), FOREACH, free_action(), gen_sort_list(), io_effect_p(), is_action_read, is_action_write, load_statement_precondition(), make_action_read_memory(), make_action_write_memory(), NIL, pips_assert, pips_debug, predicate_system, rectangularization_region(), region, REGION, region_action, region_any_reference, region_dup(), region_entity, region_system, std_file_effect_p(), step_private_p(), and transformer_relation.

Referenced by compute_recv_regions(), and compute_send_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_print_effects_list()

void debug_print_effects_list	(	list	l,
		string	txt
	)

Parameters

txt

xt

Definition at line 334 of file analyse.c.

{
  if(ENDP(l))
    pips_debug(1, "%s empty\n", txt);
  else
    {
      bool property_prettyprint_scalar_regions = get_bool_property("PRETTYPRINT_SCALAR_REGIONS");
      set_bool_property("PRETTYPRINT_SCALAR_REGIONS", true);
 
      FOREACH(EFFECT, eff, l)
        {
          string str_reg = text_to_string(text_rw_array_regions(CONS(EFFECT, eff, NIL)));
          pips_debug(1, "%s %p : %s\n", txt, eff, str_reg); free(str_reg);
        }
      set_bool_property("PRETTYPRINT_SCALAR_REGIONS", property_prettyprint_scalar_regions);
    }
}

References CONS, EFFECT, ENDP, FOREACH, free(), get_bool_property(), NIL, pips_debug, set_bool_property(), text_rw_array_regions(), and text_to_string().

Referenced by compute_recv_regions(), compute_send_regions(), step_analyse_CHAINS_DG(), step_print_directives_regions(), step_print_effect_path(), step_translate_and_map_step_regions(), step_update_comm(), and step_update_SUMMARY_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

get_directive_statement_region()

static effect get_directive_statement_region ( effect  reg )

static

Definition at line 289 of file analyse.c.

{
  effect directive_statement_region;
  pips_debug(4, "begin\n");
 
  list path = step_get_effect_path(reg);
  assert(!ENDP(path));
  directive_statement_region = step_point_data(STEP_POINT(CAR(path)));
 
  pips_debug(4, "end\n");
  return directive_statement_region;
}

References assert, CAR, ENDP, pips_debug, step_get_effect_path(), STEP_POINT, and step_point_data.

Referenced by step_set_step_partial().

Here is the call graph for this function:

Here is the caller graph for this function:

interlaced_basic_workchunk_regions_p()

static bool interlaced_basic_workchunk_regions_p ( region  reg, list  index_l  )

static

Definition at line 622 of file analyse.c.

{
  if(ENDP(index_l))
    return false;
 
  bool interlaced_p;
  Psysteme s = sc_copy(region_system(reg));
  Psysteme s_prime = sc_copy(s);
 
  FOREACH(ENTITY, index, index_l)
    {
      add_intermediate_value(index);
      entity index_prime = entity_to_intermediate_value(index);
      s_prime = sc_variable_rename(s_prime, (Variable)index, (Variable)index_prime);
 
      // contrainte I<I' qui s'ecrit : I-I'+1 <= 0
      Pcontrainte c = contrainte_make(vect_make(VECTEUR_NUL,
                                    (Variable) index, VALUE_ONE,
                                    (Variable) index_prime, VALUE_MONE,
                                    TCST, VALUE_ONE));
      sc_add_inegalite(s, c);
    }
 
  s = sc_append(s, s_prime);
  sc_rm(s_prime);
 
  s->base = BASE_NULLE;
  sc_creer_base(s);
 
  interlaced_p = sc_integer_feasibility_ofl_ctrl(s, NO_OFL_CTRL, true);
 
  sc_rm(s);
  pips_debug(2,"check interlaced %s : %s\n", entity_name(region_entity(reg)), interlaced_p?"true":"false");
  return interlaced_p;
}

References add_intermediate_value(), Ssysteme::base, BASE_NULLE, contrainte_make(), ENDP, ENTITY, entity_name, entity_to_intermediate_value(), FOREACH, NO_OFL_CTRL, pips_debug, region_entity, region_system, sc_add_inegalite(), sc_append(), sc_copy(), sc_creer_base(), sc_integer_feasibility_ofl_ctrl(), sc_rm(), sc_variable_rename(), TCST, VALUE_MONE, VALUE_ONE, vect_make(), and VECTEUR_NUL.

Referenced by step_compute_step_interlaced().

Here is the call graph for this function:

Here is the caller graph for this function:

load_step_comm()

void load_step_comm

(

void

)

Definition at line 190 of file analyse.c.

{
  step_comm comms = (step_comm)db_get_memory_resource(DBR_STEP_COMM, "", true);
 
  set_step_effect_path(step_comm_path(comms));
  set_step_interlaced(step_comm_interlaced(comms));
  set_step_partial(step_comm_partial(comms));
}

References db_get_memory_resource(), step_comm_interlaced, step_comm_partial, and step_comm_path.

Referenced by step_analyse(), and step_compile_analysed_module().

Here is the call graph for this function:

Here is the caller graph for this function:

rectangularization_region()

region rectangularization_region

(

region

reg

)

Definition at line 395 of file analyse.c.

{
  reference r = region_any_reference(reg);
  list ephis = expressions_to_entities(reference_indices(r));
  Pbase phis = list_to_base(ephis);
  gen_free_list(ephis);
  region_system(reg) = sc_rectangular_hull(region_system(reg), phis);
  base_rm(phis);
  return reg;
}

References base_rm, expressions_to_entities(), gen_free_list(), list_to_base(), reference_indices, region_any_reference, region_system, and sc_rectangular_hull().

Referenced by create_step_regions(), and loop_basic_workchunk_to_workchunk().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_step_comm()

void reset_step_comm

(

void

)

Definition at line 199 of file analyse.c.

{
  reset_step_effect_path();
  reset_step_interlaced();
  reset_step_partial();
}

Referenced by step_compile_analysed_module().

Here is the caller graph for this function:

step_add_point_into_effect_path()

static void step_add_point_into_effect_path ( effect  new_eff, entity  module, statement  stmt, effect  previous_eff  )

static

Definition at line 227 of file analyse.c.

{
  pips_debug(4, "begin\n");
  step_point point;
  point = make_step_point(module, stmt, previous_eff);
  store_step_effect_path(new_eff, point);
  pips_debug(4, "end\n");
}

References make_step_point(), module, and pips_debug.

Referenced by step_init_effect_path(), step_translate_and_map(), and summarize_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_analyse()

bool step_analyse

(

const char *

module_name

)

remove_from_summary_send et remove_from_summary_recv contain only directive regions and translated regions. They do not contain summary regions.

Parameters

module_name

odule_name

Definition at line 1429 of file analyse.c.

{
  debug_on("STEP_ANALYSE_DEBUG_LEVEL");
  bool exist_regions_p;
  pips_debug(2, "begin %d module_name = %s\n", __LINE__, module_name);
 
  entity module = local_name_to_top_level_entity(module_name);
  set_current_module_entity(module);
 
  set_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_out_effects((statement_effects) db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
  set_in_effects((statement_effects) db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
 
  statement body = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  set_current_module_statement(body);
  set_ordering_to_statement(body);
 
  init_convex_rw_regions(module_name);
  set_methods_for_convex_effects();
 
  step_directives_init(0);
 
  load_step_comm();
 
  step_statement_path_init(body);
 
  init_step_send_regions();
  init_step_recv_regions();
 
  exist_regions_p = step_compute_SENDRECV_regions(module, body);
 
  pips_debug(2, "exist_regions_p = %d\n", exist_regions_p);
 
  if(exist_regions_p)
    {
      set remove_from_summary_send, remove_from_summary_recv;
      list full_send_l, partial_send_l;
 
      step_analyse_CHAINS_DG(module_name, &remove_from_summary_send, &remove_from_summary_recv);
 
      /* remove_from_summary_send et remove_from_summary_recv contain
         only directive regions and translated regions. They do not
         contain summary regions. */
 
      step_update_SUMMARY_SENDRECV_regions(remove_from_summary_send, remove_from_summary_recv, &full_send_l, &partial_send_l);
 
      /*
        full_send_l are TRANSLATED or DIRECTIVE regions.
        partial_send_l are SUMMARY regions.
      */
      step_update_comm(full_send_l, partial_send_l);
    }
 
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_SEND_REGIONS, module_name, get_step_send_regions());
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_RECV_REGIONS, module_name, get_step_recv_regions());
 
  reset_step_send_regions();
  reset_step_recv_regions();
 
  step_statement_path_finalize();
 
  store_step_comm();
 
  step_directives_reset();
 
  generic_effects_reset_all_methods();
  reset_convex_rw_regions(module_name);
 
  reset_ordering_to_statement();
  reset_current_module_statement();
 
  reset_in_effects();
  reset_out_effects();
  reset_rw_effects();
 
  reset_current_module_entity();
 
  pips_debug(2, "End step_analyse\n");
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, generic_effects_reset_all_methods(), init_convex_rw_regions(), load_step_comm(), local_name_to_top_level_entity(), module, module_name(), pips_debug, reset_convex_rw_regions(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_ordering_to_statement(), reset_out_effects(), reset_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_methods_for_convex_effects(), set_ordering_to_statement(), set_out_effects(), set_rw_effects(), step_analyse_CHAINS_DG(), step_compute_SENDRECV_regions(), step_directives_init(), step_directives_reset(), step_statement_path_finalize(), step_statement_path_init(), step_update_comm(), step_update_SUMMARY_SENDRECV_regions(), and store_step_comm().

Here is the call graph for this function:

step_analyse_CHAINS_DG()

static void step_analyse_CHAINS_DG ( const char *  module_name, set *  remove_from_summary_send, set *  remove_from_summary_recv  )

static

for graph data structure, see newgen/graph.pdf

CHAINS is computed by the REGION_CHAINS phase.

Definition at line 1248 of file analyse.c.

{
  graph dependences_graph = (graph) db_get_memory_resource(DBR_CHAINS, module_name, true);
 
  *remove_from_summary_send = set_make(set_pointer);
  *remove_from_summary_recv = set_make(set_pointer);
 
  pips_debug(1, "################ CHAINS DG %s ###############\n", module_name);
 
  /* for graph data structure, see newgen/graph.pdf */
  /* CHAINS is computed by the REGION_CHAINS phase. */
 
  FOREACH(VERTEX, v1, graph_vertices(dependences_graph))
    {
      FOREACH(SUCCESSOR, su, vertex_successors(v1))
        {
          statement s1 = vertex_to_statement(v1);
          statement s2 = vertex_to_statement(successor_vertex(su));
          list s1_send_l = NIL;
          list s2_recv_l = NIL;
 
          ifdebug(2)
            {
              pips_debug(2, "new s1->s2 \n");
              pips_debug(2, "from %s", safe_statement_identification(s1));
              pips_debug(2, "to %s", safe_statement_identification(s2));
              STEP_DEBUG_STATEMENT(2, "statement s1", s1);
               STEP_DEBUG_STATEMENT(2, "statement s2", s2);
            }
 
 
          step_compute_CHAINS_DG_SENDRECV_regions(s1, s2, &s1_send_l, &s2_recv_l);
 
          ifdebug(2)
            {
              debug_print_effects_list(s1_send_l, "SEND S1");
              debug_print_effects_list(s2_recv_l, "RECV S2");
            }
 
          step_compute_CHAINS_DG_remove_summary_regions(su, s1_send_l, s2_recv_l, remove_from_summary_send, remove_from_summary_recv);
 
          pips_debug(2, "end statement s1->s2\n");
        }
    }
  pips_debug(2, "end\n");
}

References db_get_memory_resource(), debug_print_effects_list(), FOREACH, graph_vertices, ifdebug, module_name(), NIL, pips_debug, s1, safe_statement_identification(), set_make(), set_pointer, step_compute_CHAINS_DG_remove_summary_regions(), step_compute_CHAINS_DG_SENDRECV_regions(), STEP_DEBUG_STATEMENT, SUCCESSOR, successor_vertex, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

step_analyse_init()

bool step_analyse_init

(

const string

module_name

)

init intrinsics

other intrinsics

Parameters

module_name

odule_name

Definition at line 361 of file analyse.c.

{
  pips_debug(2, "begin for module \"%s\".\n", module_name);
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_COMM, "", make_step_comm(make_map_effect_step_point(), make_map_effect_bool(), make_map_effect_bool()));
 
  string srcpath = strdup(PIPS_RUNTIME_DIR "/" STEP_DEFAULT_RT_H);
  string old_path = pips_srcpath_append(srcpath);
  free(old_path);
  free(srcpath);
 
  /* init intrinsics */
  static struct intrin {
    char * name;
    intrinsic_desc_t desc;
  } step_intrinsics [] = {
#include "STEP_RT_intrinsic.h"
    { NULL , {NULL, 0} }
  };
  for(struct intrin *p = step_intrinsics;p->name;++p)
    register_intrinsic_handler(p->name,&(p->desc));
 
  /* other intrinsics */
  static IntrinsicDescriptor IntrinsicTypeDescriptorTable[] =
    {
#include "STEP_RT_bootstrap.h"
      {NULL, 0, 0, 0, 0}
    };
  for(IntrinsicDescriptor *p=IntrinsicTypeDescriptorTable;p->name;p++)
    register_intrinsic_type_descriptor(p) ;
 
  pips_debug(2, "end\n");
  return true;
}

References DB_PUT_MEMORY_RESOURCE, free(), make_map_effect_bool(), make_map_effect_step_point(), make_step_comm(), module_name(), IntrinsicDescriptor::name, pips_debug, pips_srcpath_append(), register_intrinsic_handler(), register_intrinsic_type_descriptor(), STEP_DEFAULT_RT_H, and strdup().

Here is the call graph for this function:

step_analysed_module_p()

bool step_analysed_module_p

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 179 of file analyse.c.

{
  return db_resource_required_or_available_p(DBR_STEP_SEND_REGIONS,  module_name);
}

References db_resource_required_or_available_p(), and module_name().

Referenced by step_compile(), and step_compile_generated_module().

Here is the call graph for this function:

Here is the caller graph for this function:

step_compute_CHAINS_DG_remove_summary_regions()

static void step_compute_CHAINS_DG_remove_summary_regions ( successor  su, list  source_send_l, list  sink_recv_l, set *  remove_from_summary_send, set *  remove_from_summary_recv  )

static

a arc label in this CHAINS DG graph is a list of conflicts, see dg.pdf

WRITE-READ dependence

Definition at line 1149 of file analyse.c.

{
  pips_debug(2, "begin\n");
  /* a arc label in this CHAINS DG graph is a list of conflicts, see dg.pdf */
 
  FOREACH(CONFLICT, c, dg_arc_label_conflicts((dg_arc_label)successor_arc_label(su)))
    {
      effect source_eff = conflict_source(c);
      effect sink_eff = conflict_sink(c);
 
      pips_debug(2,"Conflict source_eff sink_eff\n");
 
      if(!(effect_write_p(source_eff) && effect_read_p(sink_eff)))
        {
          pips_debug(2,"not WRITE->READ dependence (ignored)\n");
          continue;
        }
 
 
      /* WRITE-READ dependence */
      pips_debug(2, "Dependence :\n\t\t%s from\t%s\t\t%s to  \t%s",
                 effect_to_string(source_eff), text_to_string(text_region(source_eff)),
                 effect_to_string(sink_eff), text_to_string(text_region(sink_eff)));
 
      bool source_send_p = concerned_entity_p(source_eff, source_send_l);
      bool sink_recv_p = concerned_entity_p(sink_eff, sink_recv_l);
 
      if (source_send_p)
        {
          if (sink_recv_p)
            {
                pips_debug(2,"optimizable SEND, SEND and RECV are already summarized at the module level\n");
            }
          else
            {
              pips_debug(2,"unoptimizable SEND (no matching RECV)\n");
 
              step_get_comparable_effects(source_send_l, source_eff, remove_from_summary_send);
            }
 
          continue;
        }
 
      if (sink_recv_p)
        {
          pips_debug(2,"no corresponding SEND, remove RECV from summarized list at the module level\n");
 
          step_get_comparable_effects(sink_recv_l, sink_eff, remove_from_summary_recv);
          continue;
        }
 
      pips_debug(2,"no SEND/RECV for %s\n",effect_to_string(source_eff));
    }
  pips_debug(2, "end\n");
}

References concerned_entity_p(), CONFLICT, conflict_sink, conflict_source, dg_arc_label_conflicts, effect_read_p, effect_to_string(), effect_write_p, FOREACH, pips_debug, step_get_comparable_effects(), successor_arc_label, text_region(), and text_to_string().

Referenced by step_analyse_CHAINS_DG().

Here is the call graph for this function:

Here is the caller graph for this function:

step_compute_CHAINS_DG_SENDRECV_regions()

static void step_compute_CHAINS_DG_SENDRECV_regions ( statement  s1, statement  s2, list *  s1_send_l, list *  s2_recv_l  )

static

compute first directive statement on suffix_sp1 and suffix_sp2

Get directive region

no directive on path thus if regions corresponding to s1 exist, they are translated regions

Get directive region

no directive on path thus if regions corresponding to s1 exist, they are translated regions

Definition at line 1205 of file analyse.c.

{
  pips_debug(3, "begin\n");
 
  /* compute first directive statement on suffix_sp1 and suffix_sp2 */
  list suffix_sp1, suffix_sp2;
  list __attribute__ ((unused)) common_sp = step_statement_path_factorise(s1, s2, &suffix_sp1, &suffix_sp2);
 
  statement first_directive_stmt1 = gen_find_if((gen_filter_func_t)step_directives_bound_p, suffix_sp1, gen_chunk_identity);
  statement first_directive_stmt2 = gen_find_if((gen_filter_func_t)step_directives_bound_p, suffix_sp2, gen_chunk_identity);
 
 
  if(!statement_undefined_p(first_directive_stmt1))
    {
      STEP_DEBUG_STATEMENT(3, "directive on statement path suffix_sp1", first_directive_stmt1);
      /* Get directive region */
      *s1_send_l = step_send_regions_list_load(first_directive_stmt1);
    }
  else
    {
      pips_debug(3, "no directive on statement path suffix_sp1\n");
      /* no directive on path thus if regions corresponding to s1 exist, they are translated regions */
      if (bound_step_send_regions_p(s1))
        *s1_send_l = step_send_regions_list_load(s1);
    }
 
  if(!statement_undefined_p(first_directive_stmt2))
    {
      STEP_DEBUG_STATEMENT(3, "directive on statement path suffix_sp2", first_directive_stmt2);
      /* Get directive region */
      *s2_recv_l = step_recv_regions_list_load(first_directive_stmt2);
    }
  else
    {
      pips_debug(3, "no directive on statement path suffix_sp2\n");
      /* no directive on path thus if regions corresponding to s1 exist, they are translated regions */
      if (bound_step_recv_regions_p(s2))
        *s2_recv_l = step_recv_regions_list_load(s2);
    }
 
  pips_debug(3, "end\n");
}

References gen_chunk_identity(), gen_find_if(), pips_debug, s1, statement_undefined_p, STEP_DEBUG_STATEMENT, step_directives_bound_p(), step_recv_regions_list_load(), step_send_regions_list_load(), and step_statement_path_factorise().

Referenced by step_analyse_CHAINS_DG().

Here is the call graph for this function:

Here is the caller graph for this function:

step_compute_SENDRECV_regions()

static bool step_compute_SENDRECV_regions ( entity  module, statement  body  )

static

Initialization of summary regions

Definition at line 1413 of file analyse.c.

{
  bool exist_regions_p = false;
  pips_debug(2, "################ REGIONS  %s ###############\n", entity_name(module));
 
  /* Initialization of summary regions */
  step_send_regions_list_store(body, NIL);
  step_recv_regions_list_store(body, NIL);
 
  gen_context_recurse(body, &exist_regions_p, statement_domain, compute_SENDRECV_regions, gen_null2);
 
  pips_debug(2, "end exist_regions_p = %d\n", exist_regions_p);
  return exist_regions_p;
}

References compute_SENDRECV_regions(), entity_name, gen_context_recurse, gen_null2(), module, NIL, pips_debug, statement_domain, step_recv_regions_list_store(), and step_send_regions_list_store().

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

step_compute_step_interlaced()

static void step_compute_step_interlaced ( list  send_l, step_directive  d  )

static

Definition at line 875 of file analyse.c.

{
  list index_l = step_directive_basic_workchunk_index(d);
  FOREACH(REGION, reg, send_l)
    {
      bool interlaced_p = interlaced_basic_workchunk_regions_p(reg, index_l);
      store_step_interlaced(reg, interlaced_p);
    }
}

References FOREACH, interlaced_basic_workchunk_regions_p(), REGION, and step_directive_basic_workchunk_index().

Referenced by compute_directive_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_get_comparable_effects()

static void step_get_comparable_effects ( list  eff_list, effect  eff, set *  effects_set  )

static

Definition at line 1135 of file analyse.c.

{
  pips_debug(2, "begin\n");
  FOREACH(EFFECT, eff2, eff_list)
    {
      if (effect_comparable_p(eff, eff2))
        {
          pips_debug(2,"############################# unoptimizable %p %s\n", eff2, entity_name(effect_entity(eff2)));
          *effects_set = set_add_element(*effects_set, *effects_set, eff2);
        }
    }
  pips_debug(2, "end\n");
}

References EFFECT, effect_comparable_p(), effect_entity(), entity_name, FOREACH, pips_debug, and set_add_element().

Referenced by step_compute_CHAINS_DG_remove_summary_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_get_effect_path()

static list step_get_effect_path ( effect  start_eff )

static

Definition at line 262 of file analyse.c.

{
  list path = NIL;
  effect current_eff = start_eff ;
 
  pips_debug(4, "begin\n");
  while(bound_step_effect_path_p(current_eff))
    {
      step_point point = load_step_effect_path(current_eff);
 
      path = CONS(STEP_POINT, point, path);
 
      if (step_point_data(point) == current_eff)
        break;
 
      current_eff = step_point_data(point);
    }
 
  ifdebug(5)
    {
      step_print_effect_path(path);
    }
 
  pips_debug(4, "end\n");
  return path;
}

References CONS, ifdebug, NIL, pips_debug, STEP_POINT, step_point_data, and step_print_effect_path().

Referenced by get_directive_statement_region().

Here is the call graph for this function:

Here is the caller graph for this function:

step_init_effect_path()

static void step_init_effect_path ( entity  module, statement  stmt, list  regions_l  )

static

Add an initial point into the path, key effect is equal to data field (effect) used as stop condition in step_get_path()

Definition at line 464 of file analyse.c.

{
  pips_debug(4,"begin\n");
 
  FOREACH(REGION, reg, regions_l)
    {
      /* Add an initial point into the path,
         key effect is equal to data field (effect)
         used as stop condition in step_get_path() */
      step_add_point_into_effect_path(reg, module, stmt, reg);
    }
 
  pips_debug(4,"end\n");
}

References FOREACH, module, pips_debug, REGION, and step_add_point_into_effect_path().

Referenced by compute_directive_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_initialize_step_partial()

static void step_initialize_step_partial ( list  send_l )

static

All SENDs are initialized as PARTIAL

Definition at line 865 of file analyse.c.

{
  FOREACH(REGION, reg, send_l)
    {
      /* All SENDs are initialized as PARTIAL */
      step_set_communication_type_partial(reg);
    }
}

References FOREACH, REGION, and step_set_communication_type_partial().

Referenced by compute_directive_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_interlaced_p()

bool step_interlaced_p

(

region

reg

)

Definition at line 167 of file analyse.c.

{
  assert(bound_step_interlaced_p(reg));
  return load_step_interlaced(reg);
}

References assert.

Referenced by region_interlaced_p().

Here is the caller graph for this function:

step_partial_p()

bool step_partial_p

(

region

reg

)

Definition at line 173 of file analyse.c.

{
  assert(bound_step_partial_p(reg));
  return load_step_partial(reg);
}

References assert.

Referenced by comm_partial_p().

Here is the caller graph for this function:

step_print_directives_regions()

static void step_print_directives_regions ( step_directive  d, list  send_l, list  recv_l  )

static

Definition at line 757 of file analyse.c.

{
  pips_debug(2, "begin\n");
  ifdebug(2)
    {
      statement stmt_basic_workchunk = step_directive_basic_workchunk(d);
      assert(!statement_undefined_p(stmt_basic_workchunk));
 
      list rw_l = load_rw_effects_list(stmt_basic_workchunk);
      list in_l = load_in_effects_list(stmt_basic_workchunk);
      list out_l = load_out_effects_list(stmt_basic_workchunk);
 
      string str_reg;
      bool property_prettyprint_scalar_regions = get_bool_property("PRETTYPRINT_SCALAR_REGIONS");
      set_bool_property("PRETTYPRINT_SCALAR_REGIONS", true);
 
      str_reg = text_to_string(text_rw_array_regions(rw_l));
      pips_debug(1, "REGIONS RW : %s\n", str_reg); free(str_reg);
      str_reg = text_to_string(text_rw_array_regions(in_l));
      pips_debug(1, "REGIONS IN : %s\n", str_reg); free(str_reg);
      str_reg = text_to_string(text_rw_array_regions(out_l));
      pips_debug(1, "REGIONS OUT : %s\n", str_reg); free(str_reg);
 
      set_bool_property("PRETTYPRINT_SCALAR_REGIONS", property_prettyprint_scalar_regions);
    }
 
  debug_print_effects_list(recv_l, "REGION RECV");
 
  if(ENDP(send_l))
    debug_print_effects_list(send_l, "REGION SEND");
  else
    {
      FOREACH(REGION, r, send_l)
        {
          pips_assert("interlaced defined", bound_step_interlaced_p(r));
          list l = CONS(EFFECT, r, NIL);
          debug_print_effects_list(l, load_step_interlaced(r)?"REGION SEND INTERLACED":"REGION SEND");
          gen_free_list(l);
        }
    }
  pips_debug(2, "end\n");
}

References assert, CONS, debug_print_effects_list(), EFFECT, ENDP, FOREACH, free(), gen_free_list(), get_bool_property(), ifdebug, load_in_effects_list(), load_out_effects_list(), load_rw_effects_list(), NIL, pips_assert, pips_debug, REGION, set_bool_property(), statement_undefined_p, step_directive_basic_workchunk(), text_rw_array_regions(), and text_to_string().

Referenced by compute_directive_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_print_effect_path()

static void step_print_effect_path ( list  path )

static

Definition at line 236 of file analyse.c.

{
  int level=1;
  FOREACH(STEP_POINT, point, path)
    {
      string txt = safe_statement_identification(step_point_stmt(point));
      pips_debug(1, "level=%d module=%s statment= %s", level, entity_name(step_point_module(point)), txt);
      free(txt);
      debug_print_effects_list(CONS(EFFECT, step_point_data(point),NIL), "step_point_data :");
      level++;
    }
}

References CONS, debug_print_effects_list(), EFFECT, entity_name, FOREACH, free(), level, NIL, pips_debug, safe_statement_identification(), STEP_POINT, step_point_data, step_point_module, and step_point_stmt.

Referenced by step_get_effect_path().

Here is the call graph for this function:

Here is the caller graph for this function:

step_recv_regions_list_add()

static void step_recv_regions_list_add ( statement  stmt, list  l_regions  )

static

Definition at line 744 of file analyse.c.

{
  pips_debug(4, "begin\n");
 
  pips_assert ("step_recv_regions", bound_step_recv_regions_p(stmt));
 
  effects e = load_step_recv_regions(stmt);
  effects_effects(e) = gen_nconc(l_regions, effects_effects(e));
  update_step_recv_regions(stmt, e);
 
  pips_debug(4, "end\n");
}

References effects_effects, gen_nconc(), pips_assert, and pips_debug.

Referenced by step_summarize_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_recv_regions_list_load()

static list step_recv_regions_list_load ( statement  s )

static

Definition at line 710 of file analyse.c.

{
  pips_debug(4, "begin\n");
  if (!bound_step_recv_regions_p(s))
    return NIL;
 
  effects e = load_step_recv_regions(s);
  ifdebug(8) pips_assert("recv regions loaded are consistent", effects_consistent_p(e));
 
  pips_debug(4, "end\n");
  return(effects_effects(e));
}

References effects_consistent_p(), effects_effects, ifdebug, NIL, pips_assert, and pips_debug.

Referenced by step_compute_CHAINS_DG_SENDRECV_regions(), step_summarize_and_map_step_regions(), and step_update_SUMMARY_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_recv_regions_list_store()

static void step_recv_regions_list_store ( statement  s, list  l_regions  )

static

Definition at line 723 of file analyse.c.

{
  pips_debug(4, "begin\n");
  effects e = make_effects(l_regions);
  ifdebug(8) pips_assert("recv regions to store are consistent", effects_consistent_p(e));
  store_step_recv_regions(s, e);
  pips_debug(4, "end\n");
}

References effects_consistent_p(), ifdebug, make_effects(), pips_assert, and pips_debug.

Referenced by compute_directive_regions(), step_compute_SENDRECV_regions(), and step_translate_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_recv_regions_list_update()

static void step_recv_regions_list_update ( statement  s, list  l_regions  )

static

Definition at line 732 of file analyse.c.

{
  pips_debug(4, "begin\n");
  if (bound_step_recv_regions_p(s))
    {
      effects e = load_step_recv_regions(s);
      effects_effects(e) = l_regions;
      update_step_recv_regions(s, e);
    }
  pips_debug(4, "end\n");
}

References effects_effects, and pips_debug.

Referenced by step_update_SUMMARY_SENDRECV_regions().

Here is the caller graph for this function:

step_send_regions_list_add()

static void step_send_regions_list_add ( statement  stmt, list  l_regions  )

static

Definition at line 698 of file analyse.c.

{
  pips_debug(4, "begin\n");
  pips_assert ("step_send_regions", bound_step_send_regions_p(stmt));
 
  effects e = load_step_send_regions(stmt);
  effects_effects(e) = gen_nconc(l_regions, effects_effects(e));
  update_step_send_regions(stmt, e);
 
  pips_debug(4, "end\n");
}

References effects_effects, gen_nconc(), pips_assert, and pips_debug.

Referenced by step_summarize_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_send_regions_list_load()

static list step_send_regions_list_load ( statement  s )

static

Definition at line 665 of file analyse.c.

{
  pips_debug(4, "begin\n");
  if (!bound_step_send_regions_p(s))
    return NIL;
 
  effects e = load_step_send_regions(s);
  ifdebug(8) pips_assert("send regions loaded are consistent", effects_consistent_p(e));
  pips_debug(4, "end\n");
  return(effects_effects(e));
}

References effects_consistent_p(), effects_effects, ifdebug, NIL, pips_assert, and pips_debug.

Referenced by step_compute_CHAINS_DG_SENDRECV_regions(), step_summarize_and_map_step_regions(), and step_update_SUMMARY_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_send_regions_list_store()

static void step_send_regions_list_store ( statement  s, list  l_regions  )

static

Definition at line 677 of file analyse.c.

{
  pips_debug(4, "begin\n");
  effects e = make_effects(l_regions);
  ifdebug(8) pips_assert("send regions to store are consistent", effects_consistent_p(e));
  store_step_send_regions(s, e);
  pips_debug(4, "end\n");
}

References effects_consistent_p(), ifdebug, make_effects(), pips_assert, and pips_debug.

Referenced by compute_directive_regions(), step_compute_SENDRECV_regions(), and step_translate_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_send_regions_list_update()

static void step_send_regions_list_update ( statement  s, list  l_regions  )

static

Definition at line 686 of file analyse.c.

{
  pips_debug(4, "begin\n");
  if (bound_step_send_regions_p(s))
    {
      effects e = load_step_send_regions(s);
      effects_effects(e) = l_regions;
      update_step_send_regions(s, e);
    }
  pips_debug(4, "end\n");
}

References effects_effects, and pips_debug.

Referenced by step_update_SUMMARY_SENDRECV_regions().

Here is the caller graph for this function:

step_set_communication_type_full()

static void step_set_communication_type_full ( effect  send_region )

static

Definition at line 325 of file analyse.c.

{
  step_set_step_partial(send_region, false);
}

References step_set_step_partial().

Referenced by step_update_comm().

Here is the call graph for this function:

Here is the caller graph for this function:

step_set_communication_type_partial()

static void step_set_communication_type_partial ( effect  send_region )

static

Definition at line 329 of file analyse.c.

{
  step_set_step_partial(send_region, true);
}

References step_set_step_partial().

Referenced by step_initialize_step_partial(), and step_update_comm().

Here is the call graph for this function:

Here is the caller graph for this function:

step_set_step_partial()

static void step_set_step_partial ( effect  send_region, bool  partial_p  )

static

Retrieve the corresponding original DIRECTIVE region from any king of region: SUMMARY, TRANSLATED or DIRECTIVE region

Definition at line 309 of file analyse.c.

{
  pips_debug(4, "begin\n");
 
  effect directive_statement_send;
 
  /* Retrieve the corresponding original DIRECTIVE
     region from any king of region: SUMMARY, TRANSLATED or DIRECTIVE region */
  directive_statement_send = get_directive_statement_region(send_region);
 
  if(!partial_p)
    store_or_update_step_partial(directive_statement_send, false);
  else if(!bound_step_partial_p(directive_statement_send))
    store_step_partial(directive_statement_send, true);
  pips_debug(4, "end\n");
}

References get_directive_statement_region(), and pips_debug.

Referenced by step_set_communication_type_full(), and step_set_communication_type_partial().

Here is the call graph for this function:

Here is the caller graph for this function:

step_statement_path_build()

static bool step_statement_path_build ( statement  stmt, list *  sp_current  )

static

Definition at line 57 of file analyse.c.

{
  *sp_current = CONS(STATEMENT, stmt, *sp_current);
 
  list sp = gen_nreverse(gen_copy_seq(*sp_current));
  hash_put(step_statement_path, stmt, sp);
 
  return true;
}

References CONS, gen_copy_seq(), gen_nreverse(), hash_put(), STATEMENT, and step_statement_path.

Referenced by step_statement_path_init().

Here is the call graph for this function:

Here is the caller graph for this function:

step_statement_path_factorise()

static list step_statement_path_factorise ( statement  s1, statement  s2, list *  suffix_sp1, list *  suffix_sp2  )

static

Definition at line 141 of file analyse.c.

{
  list common_sp = NIL;
 
  pips_debug(5, "begin\n");
 
  *suffix_sp1 = step_statement_path_get(s1);
  *suffix_sp2 = step_statement_path_get(s2);
 
  while(!ENDP(*suffix_sp1) && !ENDP(*suffix_sp2) && STATEMENT(CAR(*suffix_sp1))==STATEMENT(CAR(*suffix_sp2)))
    {
      common_sp = CONS(STATEMENT, STATEMENT(CAR(*suffix_sp1)), common_sp);
      POP(*suffix_sp1);
      POP(*suffix_sp2);
    }
 
  pips_debug(5, "end\n");
  return common_sp;
}

References CAR, CONS, ENDP, NIL, pips_debug, POP, s1, STATEMENT, and step_statement_path_get().

Referenced by step_compute_CHAINS_DG_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_statement_path_finalize()

static void step_statement_path_finalize ( void  )

static

Definition at line 80 of file analyse.c.

{
  assert(!hash_table_undefined_p(step_statement_path));
 
  HASH_MAP(stmt, sp,
           {
             gen_free_list(sp);
           }, step_statement_path)
 
  hash_table_free(step_statement_path);
  step_statement_path = hash_table_undefined;
}

References assert, gen_free_list(), HASH_MAP, hash_table_free(), hash_table_undefined, hash_table_undefined_p, and step_statement_path.

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

step_statement_path_first_directive_statement()

static statement step_statement_path_first_directive_statement ( statement  stmt )

static

Definition at line 98 of file analyse.c.

{
  list sp = step_statement_path_get(stmt);
 
  statement first_directive_stmt;
 
  first_directive_stmt = gen_find_if((gen_filter_func_t)step_directives_bound_p, sp, gen_chunk_identity);
 
  return first_directive_stmt;
}

References gen_chunk_identity(), gen_find_if(), step_directives_bound_p(), and step_statement_path_get().

Referenced by step_summarize_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_statement_path_get()

static list step_statement_path_get ( statement  stmt )

static

Definition at line 93 of file analyse.c.

{
  return hash_get(step_statement_path, stmt);
}

References hash_get(), and step_statement_path.

Referenced by step_statement_path_factorise(), and step_statement_path_first_directive_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

step_statement_path_init()

static void step_statement_path_init ( statement  body )

static

Definition at line 71 of file analyse.c.

{
  assert(hash_table_undefined_p(step_statement_path));
  step_statement_path = hash_table_make(hash_pointer, HASH_DEFAULT_SIZE);
 
  list sp_current = NIL;
  gen_context_recurse(body, &sp_current, statement_domain, step_statement_path_build, step_statement_path_unbuild);
}

References assert, gen_context_recurse, HASH_DEFAULT_SIZE, hash_pointer, hash_table_make(), hash_table_undefined_p, NIL, statement_domain, step_statement_path, step_statement_path_build(), and step_statement_path_unbuild().

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

step_statement_path_unbuild()

static void step_statement_path_unbuild ( statement  stmt, list *  sp_current  )

static

Definition at line 66 of file analyse.c.

{
  gen_remove_once(sp_current, stmt);
}

References gen_remove_once().

Referenced by step_statement_path_init().

Here is the call graph for this function:

Here is the caller graph for this function:

step_summarize_and_map_step_regions()

static void step_summarize_and_map_step_regions ( statement  stmt )

static

search for the first stmt of type directive_stmt in the path from the body to stmt S

if the first_directive_stmt is different than stmt, it means that stmt is imbricated inside another directive.

In case of an imbricated statement, regions attached to stmt are not summarized at the module level.

Store SEND summary regions

Store RECV summary regions

Definition at line 822 of file analyse.c.

{
  /*
    For the statement stmt included in a module,
        add the list of regions at the statement level to the list of regions at the module level.
 
    Summarized_send_l (resp. recv_l) means list of send (resp. recv)
    regions at the module level.
  */
  pips_debug(4, "begin\n");
 
  /* search for the first stmt of type directive_stmt in the path from the
     body to stmt S
 
     if the first_directive_stmt is different than stmt, it means that
     stmt is imbricated inside another directive.
 
     In case of an imbricated statement, regions attached to stmt are
     not summarized at the module level.
  */
  statement first_directive_stmt = step_statement_path_first_directive_statement(stmt);
 
  if(statement_undefined_p(first_directive_stmt) || first_directive_stmt == stmt)
    {
      entity module = get_current_module_entity();
      statement body = get_current_module_statement();
      list summarized_send_l, summarized_recv_l;
 
      pips_assert("stmt != body", stmt != body);
      pips_assert("statement with step regions", bound_step_send_regions_p(stmt) && bound_step_recv_regions_p(stmt));
 
      summarized_send_l = summarize_and_map_step_regions(step_send_regions_list_load(stmt), module, body);
      /* Store SEND summary regions */
      step_send_regions_list_add(body, summarized_send_l);
      summarized_recv_l = summarize_and_map_step_regions(step_recv_regions_list_load(stmt), module, body);
      /* Store RECV summary regions */
      step_recv_regions_list_add(body, summarized_recv_l);
 
      pips_debug(4, " SEND and RECV propagated on module %s\n", entity_name(module));
    }
  pips_debug(4, "end\n");
}

References entity_name, get_current_module_entity(), get_current_module_statement(), module, pips_assert, pips_debug, statement_undefined_p, step_recv_regions_list_add(), step_recv_regions_list_load(), step_send_regions_list_add(), step_send_regions_list_load(), step_statement_path_first_directive_statement(), and summarize_and_map_step_regions().

Referenced by compute_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_translate_and_map()

static list step_translate_and_map ( statement  stmt, list  effects_called_l  )

static

for generic_effects_backward_translation()

for generic_effects_backward_translation() cf. summary_rw_effects_engine() dans Libs/effects-generic/rw_effects_engine.c

to avoid low level debug messages of generic_effects_backward_translation

create a new translated effect in list caller_l

map

one called effect should produce a unique translated effect

Definition at line 939 of file analyse.c.

{
  pips_debug(2, "begin\n");
 
  effect translated_eff;
  list translated_l = NIL;
  entity module = get_current_module_entity();
  entity called = call_function(statement_call(stmt));
  list args = call_arguments(statement_call(stmt));
  transformer context = load_statement_precondition(stmt); /* for generic_effects_backward_translation() */
 
  make_effects_private_current_context_stack(); /* for generic_effects_backward_translation()
                                                   cf. summary_rw_effects_engine()
                                                   dans Libs/effects-generic/rw_effects_engine.c */
 
  FOREACH(EFFECT, called_eff, effects_called_l)
    {
      /* to avoid low level debug messages of generic_effects_backward_translation */
      setenv("REGION_TRANSLATION_DEBUG_LEVEL", "0", 0);
      debug_on("REGION_TRANSLATION_DEBUG_LEVEL");
 
      /* create a new translated effect in list caller_l */
      list tmp_l = CONS(EFFECT, called_eff, NIL);
      list caller_l = generic_effects_backward_translation(called, args, tmp_l, context);
 
      debug_off();
 
      if(gen_length(caller_l)>1)
        {
          pips_user_warning("to many effect at callsite : %d effect\n", gen_length(caller_l));
          pips_debug(1, "input effect list (called_eff) :\n %s", text_to_string(text_rw_array_regions(tmp_l)));
          pips_debug(0, "output effect list (caller_l) :\n %s", text_to_string(text_rw_array_regions(caller_l)));
          list keep_l = NIL;
 
          FOREACH(EFFECT, eff, caller_l)
            {
              if (anywhere_effect_p(eff) && effect_action_tag(called_eff)==effect_action_tag(eff))
                {
                  gen_free_list(keep_l);
                  keep_l = CONS(EFFECT, eff, NIL);
                  pips_debug(0, "keep only %s", text_to_string(text_rw_array_regions(keep_l)));
                  break;
                }
 
              reference r = effect_any_reference(eff);
              if(entity_array_p(reference_variable(r)))
                keep_l = CONS(EFFECT, eff, keep_l);
              else
                pips_debug(0, "drop effect on not array entity : %s", text_to_string(text_rw_array_regions(CONS(EFFECT, eff, NIL))));
            }
          gen_free_list(caller_l);
          caller_l = keep_l;
        }
 
      /* map */
      switch (gen_length(caller_l))
        {
        case 1:
          /* one called effect should produce a unique translated effect */
          translated_eff = EFFECT(CAR(caller_l));
          pips_debug(2, "translate called_eff = %p, translated_eff = %p\n", called_eff, translated_eff);
          step_add_point_into_effect_path(translated_eff, module, stmt, called_eff);
          translated_l = gen_nconc(translated_l, caller_l);
        case 0:
          break;
        default:
          pips_debug(0, "Error\n");
          pips_debug(0, "input effect list (called_eff) :\n %s\n", text_to_string(text_rw_array_regions(tmp_l)));
          pips_debug(0, "output effect list (caller_l) :\n %s\n", text_to_string(text_rw_array_regions(caller_l)));
          pips_assert("gen_length(caller_l)<2", 0);
        }
      gen_free_list(tmp_l);
    }
 
  free_effects_private_current_context_stack();
  pips_debug(2, "end\n");
  return translated_l;
}

References anywhere_effect_p(), call_arguments, call_function, CAR, CONS, debug_off, debug_on, EFFECT, effect_action_tag, effect_any_reference, entity_array_p(), FOREACH, free_effects_private_current_context_stack(), gen_free_list(), gen_length(), gen_nconc(), generic_effects_backward_translation(), get_current_module_entity(), load_statement_precondition(), make_effects_private_current_context_stack(), module, NIL, pips_assert, pips_debug, pips_user_warning, reference_variable, statement_call(), step_add_point_into_effect_path(), text_rw_array_regions(), and text_to_string().

Referenced by step_translate_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_translate_and_map_step_regions()

static bool step_translate_and_map_step_regions ( statement  stmt )

static

SEND

Store SEND translated regions

RECV

Store RECV translated regions

Definition at line 1021 of file analyse.c.

{
  entity called;
  list caller_l, called_l;
  statement_effects regions;
  bool new_region_p = false;
 
  pips_debug(2, "begin\n");
  assert(statement_call_p(stmt));
  called = call_function(statement_call(stmt));
 
  assert(entity_module_p(called));
  statement called_body = (statement) db_get_memory_resource(DBR_CODE, entity_user_name(called), true);
 
  ifdebug(1)
    {
      pips_debug(1,"------------------> CALL\n");
      string txt = safe_statement_identification(stmt);
      pips_debug(1, "%s\n", txt);
      free(txt);
    }
 
  /* SEND */
  regions = (statement_effects)db_get_memory_resource(DBR_STEP_SEND_REGIONS, entity_user_name(called), true);
  called_l = effects_effects(apply_statement_effects(regions, called_body));
  caller_l = step_translate_and_map(stmt, called_l);
  /* Store SEND translated regions */
  step_send_regions_list_store(stmt, caller_l);
 
  new_region_p |= !ENDP(caller_l);
 
  ifdebug(2)
    {
      debug_print_effects_list(called_l, "CALLED REGIONS SEND");
      debug_print_effects_list(caller_l, "CALLER REGIONS SEND");
    }
 
  /* RECV */
  regions = (statement_effects)db_get_memory_resource(DBR_STEP_RECV_REGIONS, entity_user_name(called), true);
  called_l = effects_effects(apply_statement_effects(regions, called_body));
  caller_l = step_translate_and_map(stmt, called_l);
  /* Store RECV translated regions */
  step_recv_regions_list_store(stmt, caller_l);
 
  new_region_p |= !ENDP(caller_l);
 
  ifdebug(2)
    {
      debug_print_effects_list(called_l, "CALLED REGIONS RECV");
      debug_print_effects_list(caller_l, "CALLER REGIONS RECV");
    }
 
  pips_debug(2, "end\n");
 
  return new_region_p;
}

References apply_statement_effects(), assert, call_function, db_get_memory_resource(), debug_print_effects_list(), effects_effects, ENDP, entity_module_p(), entity_user_name(), free(), ifdebug, pips_debug, safe_statement_identification(), statement_call(), statement_call_p(), step_recv_regions_list_store(), step_send_regions_list_store(), and step_translate_and_map().

Referenced by compute_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_update_comm()

static void step_update_comm ( list  full_send_l, list  partial_send_l  )

static

Definition at line 1383 of file analyse.c.

{
  pips_debug(2, "begin\n");
 
  FOREACH(EFFECT, eff, full_send_l)
    {
      step_set_communication_type_full(eff);
    }
  FOREACH(EFFECT, eff, partial_send_l)
    {
      step_set_communication_type_partial(eff);
    }
 
  ifdebug(1)
    if(entity_main_module_p(get_current_module_entity()))
      {
        pips_debug(1, "################ COMM ###############\n");
        MAP_EFFECT_BOOL_MAP(eff, partial,
                            {
                              step_point point = load_step_effect_path(eff);
                              pips_debug(1, "module : %s\n", entity_user_name(step_point_module(point)));
                              ifdebug(2)
                                print_statement(step_point_stmt(point));
                              debug_print_effects_list(CONS(EFFECT,step_point_data(point),NIL), partial?"COMMUNICATION PARTIAL":"COMMUNICATION FULL");
                            }, get_step_partial());
      }
 
  pips_debug(2, "end\n");
}

References CONS, debug_print_effects_list(), EFFECT, entity_main_module_p(), entity_user_name(), FOREACH, get_current_module_entity(), ifdebug, MAP_EFFECT_BOOL_MAP, NIL, pips_debug, print_statement(), step_point_data, step_point_module, step_point_stmt, step_set_communication_type_full(), and step_set_communication_type_partial().

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

step_update_SUMMARY_SENDRECV_regions()

static void step_update_SUMMARY_SENDRECV_regions ( set  remove_from_summary_send, set  remove_from_summary_recv, list *  full_send_l, list *  partial_send_l  )

static

Regions corresponding to body are SYMMARY regions

Store SEND summary regions

Regions corresponding to body are SYMMARY regions

Store RECV summary regions

Definition at line 1340 of file analyse.c.

{
  statement body = get_current_module_statement();
  list tmp_summary_send;
  list tmp_summary_recv;
  list final_summary_send = NIL;
  list final_summary_recv = NIL;
 
  pips_debug(2, "begin\n");
 
  /* Regions corresponding to body are SYMMARY regions */
  tmp_summary_send = step_send_regions_list_load(body);
  update_SUMMARY_SENDRECV_regions(remove_from_summary_send, tmp_summary_send, &final_summary_send);
  /* Store SEND summary regions */
  step_send_regions_list_update(body, final_summary_send);
 
  /* Regions corresponding to body are SYMMARY regions */
  tmp_summary_recv = step_recv_regions_list_load(body);
  update_SUMMARY_SENDRECV_regions(remove_from_summary_recv, tmp_summary_recv, &final_summary_recv);
  /* Store RECV summary regions */
  step_recv_regions_list_update(body, final_summary_recv);
 
  ifdebug(2)
    {
      debug_print_effects_list(final_summary_send, "FINAL SUMMARIZED SEND");
      debug_print_effects_list(final_summary_recv, "FINAL SUMMARIZED RECV");
    }
 
  /*
     full_send_l are TRANSLATED or DIRECTIVE regions.
     partial_send_l are SUMMARY regions.
 
    They will both be to retrieve the corresponding original DIRECTIVE
    region.
    This can be done from any SUMMARY or TRANSLATED and DIRECTIVE (of
    course) kind of region.
  */
 
  *full_send_l = set_to_list(remove_from_summary_send);
  *partial_send_l = final_summary_send;
  pips_debug(2, "end\n");
}

References debug_print_effects_list(), get_current_module_statement(), ifdebug, NIL, pips_debug, set_to_list(), step_recv_regions_list_load(), step_recv_regions_list_update(), step_send_regions_list_load(), step_send_regions_list_update(), and update_SUMMARY_SENDRECV_regions().

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

store_step_comm()

void store_step_comm

(

void

)

Definition at line 206 of file analyse.c.

{
  step_comm comms = (step_comm)db_get_memory_resource(DBR_STEP_COMM, "", true);
 
  step_comm_path(comms) = get_step_effect_path();
  step_comm_interlaced(comms) = get_step_interlaced();
  step_comm_partial(comms) = get_step_partial();
 
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_COMM, "", comms);
 
  reset_step_effect_path();
  reset_step_interlaced();
  reset_step_partial();
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, step_comm_interlaced, step_comm_partial, and step_comm_path.

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

summarize_and_map_step_regions()

static list summarize_and_map_step_regions ( list  effect_l, entity  module, statement  body  )

static

Definition at line 800 of file analyse.c.

{
  pips_debug(4, "begin\n");
  list summarized_l = NIL;
 
  FOREACH(EFFECT, eff, effect_l)
    {
      effect new_eff = copy_effect(eff);
 
      pips_debug(4, "tmp summarize eff = %p new_eff = %p\n", eff, new_eff);
      step_add_point_into_effect_path(new_eff, module, body, eff);
      summarized_l = CONS(EFFECT, new_eff, summarized_l);
    }
 
  pips_debug(4, "end\n");
  return summarized_l;
}

References CONS, copy_effect(), EFFECT, FOREACH, module, NIL, pips_debug, and step_add_point_into_effect_path().

Referenced by step_summarize_and_map_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

update_SUMMARY_SENDRECV_regions()

static void update_SUMMARY_SENDRECV_regions ( set  remove_from_summary_regions, list  tmp_summary_regions_l, list *  final_summary_regions_l  )

static

Definition at line 1296 of file analyse.c.

{
  pips_debug(1, "begin\n");
 
 /*
 
    The effects in the remove_from_summary_send and
    remove_from_summary_send sets are not SUMMARY. They can be
    DIRECTIVE regions or TRANSLATED regions.
 
    They are built from SEND and RECV effects corresponding to
    statements S1 and S2 of the DG.
 
    We need to get pathpoint corresponding to the SUMMARY
    effects to retrieve the original effects (from which summary was
    computed).
 
    Because the pathpoint corresponds to a SUMMARY, the effect in the
    pathpoint data field can be either TRANSLATED or DIRECTIVE region.
 
   */
 
   FOREACH(EFFECT, summ_eff, tmp_summary_regions_l)
    {
      assert(bound_step_effect_path_p(summ_eff));
 
      step_point point = load_step_effect_path(summ_eff);
      effect from_region = step_point_data(point);
 
      /*
        from_region can be either DIRECTIVE or TRANSLATED region. See comments above.
 
        if from_region corresponding to the SUMMARY effect is not is
        the remove set then add the SUMMARY effect into the final SUMMARY regions list.
       */
      if(!set_belong_p(remove_from_summary_regions, from_region))
        *final_summary_regions_l = CONS(EFFECT, summ_eff, *final_summary_regions_l);
      else
        pips_debug(2, "drop unoptimizable tmp_summary %p -> data %p\n", summ_eff, step_point_data(point));
    }
 
  pips_debug(1, "end\n");
}

References assert, CONS, EFFECT, FOREACH, pips_debug, set_belong_p(), and step_point_data.

Referenced by step_update_SUMMARY_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

step_statement_path

hash_table step_statement_path = hash_table_undefined

static

The step_analyse phase computes three main resources:

• step_comm
• step_send_regions
• step_recv_regions Declaration of the step_send_regions and step_send_regions resources.

Store all different kind of regions:

• directive regions (at directive statement level)
• translated regions (at call statement level)
• summary regions (at body statement level)

Definition at line 55 of file analyse.c.

Referenced by step_statement_path_build(), step_statement_path_finalize(), step_statement_path_get(), and step_statement_path_init().