compile_regions.c File Reference

#include "defines-local.h"
#include "prettyprint.h"

Include dependency graph for compile_regions.c:

Go to the source code of this file.

Functions
static bool	combinable_regions_p (region r1, region r2)
	Copyright 2007-2012 Alain Muller, Frederique Silber-Chaussumier. More...
static bool	region_interlaced_p (list send_regions, region r)
static bool	reduction_p (set reductions_l[STEP_UNDEF_REDUCE], entity e)
static bool	comm_partial_p (list send_regions, region r)
static statement	bound_to_statement (entity mpi_module, list expr_bound, entity array_region, string bound_name, int dim, list index)
static list	phi_free_contraints_to_expressions (bool equality, region reg)
static bool	contraintes_to_expression (bool equality, entity phi, Psysteme sys, list *expr_l, list *expr_u)
static void	compute_region (entity mpi_module, region reg, entity array_region, bool loop_p, statement *compute_regions_stmt)
static bool	region_reduction_p (set reductions_l[STEP_UNDEF_REDUCE], region reg)
static void	generate_call_set_regionarray (entity mpi_module, region reg, entity array_region, bool loop_p, bool is_reduction, bool is_interlaced, statement *set_regions_stmt)
static void	generate_call_stepalltoall (entity mpi_module, region reg, bool is_reduction, bool is_interlaced, bool is_partial, statement *stepalltoall_stmt)
	pourquoi flush et non pas alltoall ? More...
static void	region_to_statement (entity mpi_module, region reg, bool loop_p, bool is_reduction, bool is_interlaced, bool is_partial, statement *compute_regions_stmt, statement *set_regionarray_stmt, statement *stepalltoall_stmt)
static void	transform_regions_to_statement (entity mpi_module, list regions_l, bool loop_p, list send_as_comm_l, set reductions_l[STEP_UNDEF_REDUCE], statement *compute_regions_stmt, statement *set_regionarray_stmt, statement *stepalltoall_stmt)
static void	add_workchunk_loop (entity mpi_module, bool loop_p, loop loop_stmt, statement *compute_regions_stmt)
void	compile_regions (entity new_module, list regions_l, bool loop_p, loop loop_stmt, list send_as_comm_l, set reductions_l[STEP_UNDEF_REDUCE], statement mpi_begin_stmt, statement mpi_end_stmt)

Function Documentation

add_workchunk_loop()

static void add_workchunk_loop ( entity  mpi_module, bool  loop_p, loop  loop_stmt, statement *  compute_regions_stmt  )

static

Definition at line 481 of file compile_regions.c.

{
  pips_debug(1, "begin\n");
  /*
    ajout de la boucle parcourant les workchunks
    suppression du test !entity_undefined_p(index) : redondant avec loop_p?
  */
  if( loop_p &&
      !ENDP(statement_block(*compute_regions_stmt)))
    {
      generate_call_get_workchunk_loopbounds(mpi_module, loop_stmt, compute_regions_stmt);
 
      generate_loop_workchunk(mpi_module, compute_regions_stmt);
    }
  pips_debug(1, "end\n");
}

References ENDP, generate_call_get_workchunk_loopbounds(), generate_loop_workchunk(), pips_debug, and statement_block().

Referenced by compile_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

bound_to_statement()

static statement bound_to_statement ( entity  mpi_module, list  expr_bound, entity  array_region, string  bound_name, int  dim, list  index  )

static

Definition at line 96 of file compile_regions.c.

{
  pips_debug(1, "begin array_region = %p\n", array_region);
 
  pips_assert("expression", !ENDP(expr_bound));
  statement s;
  entity op = entity_undefined;
  list dims = CONS(EXPRESSION, step_symbolic_expression(bound_name, mpi_module),
                   CONS(EXPRESSION, int_to_expression(dim), gen_full_copy_list(index)));
 
  bool is_fortran = fortran_module_p(get_current_module_entity());
  if (!is_fortran)
    {
      list l = NIL;
      FOREACH(EXPRESSION, e, dims)
        {
          l = CONS(EXPRESSION, MakeBinaryCall(CreateIntrinsic(MINUS_C_OPERATOR_NAME),
                                              e,
                                              int_to_expression(1)),
                   l);
        }
      dims = l;
    }
 
  expression expr = reference_to_expression(make_reference(array_region, dims));
 
  if ( gen_length(expr_bound) != 1 )
    {
      if(strncmp(bound_name, STEP_INDEX_SLICE_LOW_NAME, strlen(bound_name)) == 0)
        op = entity_intrinsic(MAX_OPERATOR_NAME);
      else if (strncmp(bound_name, STEP_INDEX_SLICE_UP_NAME, strlen(bound_name)) == 0)
        op = entity_intrinsic(MIN_OPERATOR_NAME);
      else
        pips_internal_error("unexpected bound name %s", bound_name);
      s = make_assign_statement(expr, call_to_expression(make_call(op, expr_bound)));
    }
  else
    s = make_assign_statement(expr, EXPRESSION(CAR(expr_bound)));
 
  pips_debug(1, "end\n");
  return s;
}

References call_to_expression(), CAR, CONS, CreateIntrinsic(), ENDP, entity_intrinsic(), entity_undefined, EXPRESSION, FOREACH, fortran_module_p(), gen_full_copy_list(), gen_length(), get_current_module_entity(), int_to_expression(), make_assign_statement(), make_call(), make_reference(), MakeBinaryCall(), MAX_OPERATOR_NAME, MIN_OPERATOR_NAME, MINUS_C_OPERATOR_NAME, NIL, pips_assert, pips_debug, pips_internal_error, reference_to_expression(), STEP_INDEX_SLICE_LOW_NAME, STEP_INDEX_SLICE_UP_NAME, and step_symbolic_expression().

Referenced by compute_region().

Here is the call graph for this function:

Here is the caller graph for this function:

combinable_regions_p()

static bool combinable_regions_p ( region  r1, region  r2  )

static

Copyright 2007-2012 Alain Muller, Frederique Silber-Chaussumier.

This file is part of STEP.

The program is distributed under the terms of the GNU General Public License.

Definition at line 19 of file compile_regions.c.

{
  bool same_var, same_act;
 
  if (region_undefined_p(r1) || region_undefined_p(r2))
    return(true);
 
  same_var = (region_entity(r1) == region_entity(r2));
  same_act = action_equal_p(region_action(r1), region_action(r2));
 
  return(same_var && same_act);
}

References action_equal_p(), region_action, region_entity, and region_undefined_p.

Referenced by comm_partial_p(), and region_interlaced_p().

Here is the call graph for this function:

Here is the caller graph for this function:

comm_partial_p()

static bool comm_partial_p ( list  send_regions, region  r  )

static

Definition at line 70 of file compile_regions.c.

{
  bool partial_p = true;
  pips_debug(1, "begin\n");
  if(region_write_p(r))
    {
      bool first = true;
 
      FOREACH(REGION, reg, send_regions)
        {
          if(combinable_regions_p(reg, r))
            {
              assert(first);
              partial_p = step_partial_p(reg);
              first = false;
            }
        }
    }
  pips_debug(1, "end partial_p = %d\n", partial_p);
  return partial_p;
}

References assert, combinable_regions_p(), FOREACH, pips_debug, REGION, region_write_p, and step_partial_p().

Referenced by transform_regions_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_regions()

void compile_regions	(	entity	new_module,
		list	regions_l,
		bool	loop_p,
		loop	loop_stmt,
		list	send_as_comm_l,
		set	reductions_l[STEP_UNDEF_REDUCE],
		statement	mpi_begin_stmt,
		statement	mpi_end_stmt
	)

Definition at line 498 of file compile_regions.c.

{
  statement compute_regions_stmt, set_regions_stmt, flush_regions_stmt;
 
  pips_debug(1, "begin regions_l = %p\n", regions_l);
 
  transform_regions_to_statement(new_module, regions_l, loop_p, send_as_comm_l, reductions_l,
                                 &compute_regions_stmt, &set_regions_stmt, &flush_regions_stmt);
 
  add_workchunk_loop(new_module, loop_p, loop_stmt, &compute_regions_stmt);
  generate_call_flush(&flush_regions_stmt);
 
  if(!ENDP(statement_block(compute_regions_stmt)))
    {
      string comment;
      statement comment_stmt = make_plain_continue_statement();
      insert_statement(mpi_begin_stmt, comment_stmt, false);
      insert_statement(mpi_begin_stmt, compute_regions_stmt, false);
      insert_statement(mpi_begin_stmt, set_regions_stmt, false);
 
      if (list_undefined_p(send_as_comm_l))
        {
          comment = strdup("\nRECV REGIONS");
          insert_statement(mpi_begin_stmt, flush_regions_stmt, false);
        }
      else
        {
          comment = strdup("\nSEND REGIONS");
          insert_statement(mpi_end_stmt, flush_regions_stmt, false);
        }
      put_a_comment_on_a_statement(comment_stmt, comment);
    }
  else
    {
      free_statement(compute_regions_stmt);
      free_statement(set_regions_stmt);
      free_statement(flush_regions_stmt);
    }
 
}

References add_workchunk_loop(), comment(), ENDP, free_statement(), generate_call_flush(), insert_statement(), list_undefined_p, make_plain_continue_statement(), pips_debug, put_a_comment_on_a_statement(), statement_block(), strdup(), and transform_regions_to_statement().

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_region()

static void compute_region ( entity  mpi_module, region  reg, entity  array_region, bool  loop_p, statement *  compute_regions_stmt  )

static

Definition at line 263 of file compile_regions.c.

{
  pips_debug(1, "begin array_region = %p\n", array_region);
  Psysteme sys = region_system(reg);
  list bounds_array = variable_dimensions(type_variable(entity_type(region_entity(reg))));
 
  if(ENDP(bounds_array))
    {
      pips_debug(0,"Current array : %s\n", entity_name(region_entity(reg)));
      pips_assert("defined array bounds", 0);
    }
 
  list index_slice = NIL;
  if (loop_p)
    {
      entity workchunk_id = step_local_slice_index(mpi_module);
      index_slice = CONS(EXPRESSION, entity_to_expression(workchunk_id), index_slice);
    }
 
  statement empty_region_stmt = statement_undefined;
  list phi_free_contraints = NIL;
  phi_free_contraints = gen_nconc(phi_free_contraints_to_expressions(true, reg), phi_free_contraints);
  phi_free_contraints = gen_nconc(phi_free_contraints_to_expressions(false, reg), phi_free_contraints);
  if (!ENDP(phi_free_contraints))
    empty_region_stmt =  make_empty_block_statement();
 
  statement compute_region_stmt = make_empty_block_statement();
  int dim = 0;
 
  // on parcourt dans l'ordre des indices (PHI1, PHI2, ...) chaque PHIi correspond a une dimension dim
 
  FOREACH(EXPRESSION, expr, reference_indices(effect_any_reference(reg)))
    {
      list expr_l = NIL;
      list expr_u = NIL;
      entity phi = reference_variable(syntax_reference(expression_syntax(expr)));
      dimension bounds_d = DIMENSION(gen_nth(dim, bounds_array));   // gen_nth numerote les element a partir de 0 et ...
      dim++; // ... les tableaux de region numerote les dimensions a partir de 1
 
      // on determine les listes d'expression expr_l (et expr_u) correspondant aux
      // contraites low (et up) portant sur la variable PHI courante
      // ex: L <= PHI1 + 1  et PHI1 -1 <= U
      // expr_l contient l'expression (L-1) et expr_u contient l'expression (U+1)
 
      //          pips_assert("empty list", ENDP(expr_l) && ENDP(expr_u));
      // recherche et transformation des contraintes d'equalites portant sur phi
      contraintes_to_expression(true, phi, sys, &expr_l, &expr_u);
      // recherche et transformation des contraintes d'inequalites portant sur phi
      contraintes_to_expression(false, phi, sys, &expr_l, &expr_u);
 
      // ajout contraintes liees aux bornes d'indexation du tableau pour la dimension courante
      if(ENDP(expr_l))
        expr_l = CONS(EXPRESSION, copy_expression(dimension_lower(bounds_d)), expr_l);
      if(ENDP(expr_u))
        expr_u = CONS(EXPRESSION, copy_expression(dimension_upper(bounds_d)), expr_u);
 
      /*
            generation des statements : array_region(bound_name, dim, index_slice) = expr_bound
      */
      statement b1 = bound_to_statement(mpi_module, expr_l, array_region, STEP_INDEX_SLICE_LOW_NAME, dim, index_slice);
      statement b2 = bound_to_statement(mpi_module, expr_u, array_region, STEP_INDEX_SLICE_UP_NAME, dim, index_slice);
 
      ifdebug(2)
        {
          pips_debug(2, "b1\n");
          print_statement(b1);
          pips_debug(2, "b2\n");
          print_statement(b2);
        }
      insert_statement(compute_region_stmt, b1, false);
      insert_statement(compute_region_stmt, b2, false);
 
      if (!ENDP(phi_free_contraints))
        {
          expr_l = CONS(EXPRESSION, copy_expression(dimension_upper(bounds_d)), NIL);
          expr_u = CONS(EXPRESSION, copy_expression(dimension_lower(bounds_d)), NIL);
 
          b1 = bound_to_statement(mpi_module, expr_l, array_region, STEP_INDEX_SLICE_LOW_NAME, dim, index_slice);
          b2 = bound_to_statement(mpi_module, expr_u, array_region, STEP_INDEX_SLICE_UP_NAME, dim, index_slice);
 
          insert_statement(empty_region_stmt, b1, false);
          insert_statement(empty_region_stmt, b2, false);
        }
 
    }
 
  if (!ENDP(phi_free_contraints))
    {
      entity and_op = entity_intrinsic(c_module_p(get_current_module_entity())?C_AND_OPERATOR_NAME:AND_OPERATOR_NAME);
      expression cond_expr = expression_list_to_binary_operator_call(phi_free_contraints, and_op);
 
      insert_statement(*compute_regions_stmt,
                       instruction_to_statement(make_instruction(is_instruction_test,
                                                                 make_test(cond_expr,
                                                                           compute_region_stmt,
                                                                           empty_region_stmt))),
                       false);
      string comment_str = strdup(" Inverted bounds correspond to empty regions\n Used when work concerns specific data ex: print A[5]\n In this case, only concerned process sends non empty regions\n");
      put_a_comment_on_a_statement(empty_region_stmt, comment_str);
    }
  else
    insert_statement(*compute_regions_stmt, compute_region_stmt, false);
 
  pips_debug(1, "end\n");
}

References AND_OPERATOR_NAME, b1, b2, bound_to_statement(), C_AND_OPERATOR_NAME, c_module_p(), CONS, contraintes_to_expression(), copy_expression(), DIMENSION, dimension_lower, dimension_upper, effect_any_reference, ENDP, entity_intrinsic(), entity_name, entity_to_expression(), entity_type, EXPRESSION, expression_list_to_binary_operator_call(), expression_syntax, FOREACH, gen_nconc(), gen_nth(), get_current_module_entity(), ifdebug, insert_statement(), instruction_to_statement(), is_instruction_test, make_empty_block_statement(), make_instruction(), make_test(), NIL, phi_free_contraints_to_expressions(), pips_assert, pips_debug, print_statement(), put_a_comment_on_a_statement(), reference_indices, reference_variable, region_entity, region_system, statement_undefined, STEP_INDEX_SLICE_LOW_NAME, STEP_INDEX_SLICE_UP_NAME, step_local_slice_index(), strdup(), syntax_reference, type_variable, and variable_dimensions.

Referenced by region_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

contraintes_to_expression()

static bool contraintes_to_expression ( bool  equality, entity  phi, Psysteme  sys, list *  expr_l, list *  expr_u  )

static

Definition at line 194 of file compile_regions.c.

{
  Pcontrainte c;
  bool found_equality=false;
 
  pips_debug(1, "begin\n");
  for(c = equality?sc_egalites(sys):sc_inegalites(sys); !found_equality && !CONTRAINTE_UNDEFINED_P(c); c = c->succ)
    {
      int coef_phi=VALUE_TO_INT(vect_coeff((Variable)phi,c->vecteur));
      if(coef_phi != 0)
        {
          expression expr;
          Pvecteur coord,v = vect_del_var(c->vecteur, (Variable)phi);
          bool up_bound = (coef_phi > 0);
          bool low_bound = !up_bound;
 
          //construction des expressions d'affectation
          if(VECTEUR_NUL_P(v))
            expr = int_to_expression(0);
          else
            {
              if (coef_phi > 0) //contrainte de type : coef_phi*phi  <= "vecteur"
                {
                  for (coord = v; coord!=NULL; coord=coord->succ)
                    val_of(coord) = -val_of(coord);
                  coef_phi = -coef_phi;
                }
 
              expr = make_vecteur_expression(v);
              if (coef_phi != -1)
                expr = make_op_exp("/", expr, int_to_expression(-coef_phi));
            }
 
          if (equality || low_bound)
            *expr_l = CONS(EXPRESSION,copy_expression(expr), *expr_l);
          if (equality || up_bound)
            *expr_u = CONS(EXPRESSION,copy_expression(expr), *expr_u);
 
          free_expression(expr);
          found_equality = equality;
        }
    }
  pips_debug(1, "end\n");
  return found_equality;
}

References CONS, CONTRAINTE_UNDEFINED_P, copy_expression(), EXPRESSION, free_expression(), int_to_expression(), make_op_exp(), make_vecteur_expression(), pips_debug, Scontrainte::succ, Svecteur::succ, val_of, VALUE_TO_INT, vect_coeff(), vect_del_var(), Scontrainte::vecteur, and VECTEUR_NUL_P.

Referenced by compute_region().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_set_regionarray()

static void generate_call_set_regionarray ( entity  mpi_module, region  reg, entity  array_region, bool  loop_p, bool  is_reduction, bool  is_interlaced, statement *  set_regions_stmt  )

static

Definition at line 376 of file compile_regions.c.

{
  pips_debug(1, "begin\n");
 
  entity array = region_entity(reg);
 
  expression expr_nb_workchunk = loop_p?entity_to_expression(get_entity_step_commsize(mpi_module)):int_to_expression(1);
  statement set_stmt = region_read_p(reg)?
    build_call_STEP_set_recvregions(array, expr_nb_workchunk, array_region):
    build_call_STEP_set_sendregions(array, expr_nb_workchunk, array_region, is_interlaced, is_reduction);
  insert_statement(*set_regions_stmt, set_stmt, false);
 
  pips_debug(1, "end\n");
}

References array, build_call_STEP_set_recvregions(), build_call_STEP_set_sendregions(), entity_to_expression(), get_entity_step_commsize(), insert_statement(), int_to_expression(), pips_debug, region_entity, and region_read_p.

Referenced by region_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_stepalltoall()

static void generate_call_stepalltoall ( entity  mpi_module, region  reg, bool  is_reduction, bool  is_interlaced, bool  is_partial, statement *  stepalltoall_stmt  )

static

pourquoi flush et non pas alltoall ?

Definition at line 392 of file compile_regions.c.

{
  entity array = region_entity(reg);
 
  if(!is_reduction)
    {
      statement comm_stmt = build_call_STEP_AllToAll(mpi_module, array, is_partial, is_interlaced);
      insert_statement(*stepalltoall_stmt, comm_stmt, false);
    }
}

References array, build_call_STEP_AllToAll(), insert_statement(), and region_entity.

Referenced by region_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

phi_free_contraints_to_expressions()

static list phi_free_contraints_to_expressions ( bool  equality, region  reg  )

static

Definition at line 139 of file compile_regions.c.

{
  Psysteme sys = region_system(reg);
  Pcontrainte c;
  list expression_l = NIL;
 
  entity comparator;
  if(c_module_p(get_current_module_entity()))
    comparator = entity_intrinsic(equality?C_EQUAL_OPERATOR_NAME:C_LESS_OR_EQUAL_OPERATOR_NAME);
  else
    comparator = entity_intrinsic(equality?EQUAL_OPERATOR_NAME:LESS_OR_EQUAL_OPERATOR_NAME);
 
  for(c = equality?sc_egalites(sys):sc_inegalites(sys); !CONTRAINTE_UNDEFINED_P(c); c = c->succ)
    {
      int coef_phi = 0;
      FOREACH(EXPRESSION, expr, reference_indices(effect_any_reference(reg)))
        {
          entity phi = reference_variable(syntax_reference(expression_syntax(expr)));
          coef_phi = VALUE_TO_INT(vect_coeff((Variable)phi,c->vecteur));
          if(coef_phi != 0)
            break;
        }
      if(coef_phi == 0)
        {
          expression expr = MakeBinaryCall(comparator,
                                           make_vecteur_expression(c->vecteur),
                                           int_to_expression(0));
          expression_l = CONS(EXPRESSION, expr, expression_l);
        }
    }
  return expression_l;
}

References C_EQUAL_OPERATOR_NAME, C_LESS_OR_EQUAL_OPERATOR_NAME, c_module_p(), CONS, CONTRAINTE_UNDEFINED_P, effect_any_reference, entity_intrinsic(), EQUAL_OPERATOR_NAME, EXPRESSION, expression_syntax, FOREACH, get_current_module_entity(), int_to_expression(), LESS_OR_EQUAL_OPERATOR_NAME, make_vecteur_expression(), MakeBinaryCall(), NIL, reference_indices, reference_variable, region_system, Scontrainte::succ, syntax_reference, VALUE_TO_INT, vect_coeff(), and Scontrainte::vecteur.

Referenced by compute_region().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_p()

static bool reduction_p ( set  reductions_l[STEP_UNDEF_REDUCE], entity  e  )

static

Definition at line 55 of file compile_regions.c.

{
  bool is_reduction = false;
  int op;
 
  pips_debug(1, "begin\n");
 
  for(op=0; !is_reduction && op<STEP_UNDEF_REDUCE; op++)
    is_reduction = set_belong_p(reductions_l[op], e);
 
  pips_debug(1, "end\n");
  return is_reduction;
}

References pips_debug, set_belong_p(), and STEP_UNDEF_REDUCE.

Referenced by compile_body(), pointer_to_initial_name(), region_reduction_p(), and step_get_directive_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

region_interlaced_p()

static bool region_interlaced_p ( list  send_regions, region  r  )

static

Definition at line 32 of file compile_regions.c.

{
  bool interlaced = false;
  pips_debug(1, "begin send_regions = %p, r = %p\n", send_regions, r);
 
  if(region_write_p(r))
    {
      bool first = true;
 
      FOREACH(REGION, reg, send_regions)
        {
          if(combinable_regions_p(reg, r))
            {
              assert(first);
              interlaced = step_interlaced_p(reg);
              first = false;
            }
        }
    }
  pips_debug(1, "end\n");
  return interlaced;
}

References assert, combinable_regions_p(), FOREACH, pips_debug, REGION, region_write_p, and step_interlaced_p().

Referenced by transform_regions_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

region_reduction_p()

static bool region_reduction_p ( set  reductions_l[STEP_UNDEF_REDUCE], region  reg  )

static

Definition at line 369 of file compile_regions.c.

{
  entity array = region_entity(reg);
 
  return region_write_p(reg) && reduction_p(reductions_l, array);
}

References array, reduction_p(), region_entity, and region_write_p.

Referenced by transform_regions_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

region_to_statement()

static void region_to_statement ( entity  mpi_module, region  reg, bool  loop_p, bool  is_reduction, bool  is_interlaced, bool  is_partial, statement *  compute_regions_stmt, statement *  set_regionarray_stmt, statement *  stepalltoall_stmt  )

static

bug bug bug si on inverse les instr expr_nb_region et region_array_name alors bug. POURQUOI??

Definition at line 403 of file compile_regions.c.

{
  pips_debug(1,"begin mpi_module = %s, region = %p\n", entity_name(mpi_module), reg);
 
  entity array = region_entity(reg);
  pips_debug(2, "array = %s\n", entity_name(array));
 
  /*
    Elimination of redundancies
  */
  region_system(reg) = sc_safe_elim_redund(region_system(reg));
 
  /*
    Add region description in comments
  */
  string str_eff = text_to_string(text_rw_array_regions(CONS(REGION, reg, NIL)));
  statement comment_stmt = make_plain_continue_statement();
  put_a_comment_on_a_statement(comment_stmt, str_eff);
 
  insert_statement(*compute_regions_stmt, comment_stmt, false);
 
 
  /*
    Create STEP_RR and STEP_SR array entities
   */
  expression expr_nb_region = loop_p?step_symbolic_expression(STEP_MAX_NB_LOOPSLICES_NAME, mpi_module):expression_undefined;
 
  /* bug bug bug si on inverse les instr expr_nb_region et region_array_name alors bug. POURQUOI??*/
 
  string region_array_name = region_read_p(reg)?STEP_RR_NAME(array):STEP_SR_NAME(array);
  pips_debug(2, "region_array_name = %s\n", region_array_name);
 
  entity region_array = step_local_regionArray(mpi_module, array, region_array_name, expr_nb_region);
  pips_debug(2, "region_array = %p\n", region_array);
 
  /*
    Compute regions
  */
  compute_region(mpi_module, reg, region_array, loop_p, compute_regions_stmt);
 
  /*
    Set regions
  */
 
  generate_call_set_regionarray(mpi_module, reg, region_array, loop_p, is_reduction, is_interlaced, set_regionarray_stmt);
 
  /*
    stepalltoall_stmt
 
    Pour les régions SEND ET (?) RECV
  */
 
  generate_call_stepalltoall(mpi_module, reg, is_reduction, is_interlaced, is_partial, stepalltoall_stmt);
 
  pips_debug(1, "end\n");
}

References array, compute_region(), CONS, entity_name, expression_undefined, generate_call_set_regionarray(), generate_call_stepalltoall(), insert_statement(), make_plain_continue_statement(), NIL, pips_debug, put_a_comment_on_a_statement(), REGION, region_entity, region_read_p, region_system, sc_safe_elim_redund(), step_local_regionArray(), STEP_MAX_NB_LOOPSLICES_NAME, STEP_RR_NAME, STEP_SR_NAME, step_symbolic_expression(), text_rw_array_regions(), and text_to_string().

Referenced by transform_regions_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

transform_regions_to_statement()

static void transform_regions_to_statement ( entity  mpi_module, list  regions_l, bool  loop_p, list  send_as_comm_l, set  reductions_l[STEP_UNDEF_REDUCE], statement *  compute_regions_stmt, statement *  set_regionarray_stmt, statement *  stepalltoall_stmt  )

static

Definition at line 460 of file compile_regions.c.

{
  pips_debug(1, "begin regions_l = %p, pure_send_l = %p\n", regions_l, send_as_comm_l);
 
  *compute_regions_stmt = make_empty_block_statement();
  *set_regionarray_stmt = make_empty_block_statement();
  *stepalltoall_stmt = make_empty_block_statement();
 
  FOREACH(REGION, reg, regions_l)
    {
      bool is_reduction = region_reduction_p(reductions_l, reg);
      bool is_interlaced = region_interlaced_p(send_as_comm_l, reg);
      bool is_partial = comm_partial_p(send_as_comm_l, reg);
 
      region_to_statement(mpi_module, reg, loop_p, is_reduction, is_interlaced, is_partial, compute_regions_stmt, set_regionarray_stmt, stepalltoall_stmt);
    }
 
  pips_debug(1, "end\n");
}

References comm_partial_p(), FOREACH, make_empty_block_statement(), pips_debug, REGION, region_interlaced_p(), region_reduction_p(), and region_to_statement().

Referenced by compile_regions().

Here is the call graph for this function:

Here is the caller graph for this function: