#include "defines-local.h"
#include "accel-util.h"
#include "semantics.h"
#include "workspace-util.h"
#include "prettyprint.h"

Include dependency graph for compile_mpi.c:

Functions
static string	step_head_hook (entity __attribute__((unused)) e)
	Copyright 2007-2012 Alain Muller, Frederique Silber-Chaussumier. More...

static void	loopbounds_substitution (entity new_module, loop loop_stmt)

static statement	compile_loopslices (entity new_module, loop loop_stmt)

static statement	compile_loopbounds (entity new_module, loop loop_stmt, statement work_stmt)

static void	compile_reduction (set reductions_l[STEP_UNDEF_REDUCE], statement before_stmt, statement after_stmt)

static void	loop_basic_workchunk_to_workchunk (statement stmt, list recv_l, list send_l)

static statement	compile_master (entity new_module, statement work_stmt)

static statement	compile_barrier (entity __attribute__((unused)) new_module, statement work_stmt)

static bool	step_get_directive_reductions (step_directive drt, set *reductions_l)

static list	duplicate_regions_referenced_entity (list referenced_entities, list regions_l)

static list	keep_recv_or_send_referenced_entity (list recv_l, list send_l, list referenced_entities)

static void	compile_body (statement directive_stmt, entity new_module, step_directive drt, int transformation, list referenced_entities, statement new_body, statement mpi_begin_stmt, statement work_stmt, statement mpi_end_stmt)

static void	update_referenced_entities (statement new_body, list *referenced_entities)

statement	compile_mpi (statement directive_stmt, string new_module_name, step_directive drt, int transformation)
	compile_mpi.c More...

Function Documentation

◆ compile_barrier()

static statement compile_barrier	(	entity __attribute__((unused))	new_module,
		statement	work_stmt
	)

static

Definition at line 235 of file compile_mpi.c.

 {
   pips_debug(1, "begin\n");
  
   statement call_stmt = call_STEP_subroutine2(RT_STEP_barrier, NULL);
   insert_statement(work_stmt, call_stmt, false);
  
   pips_debug(1, "end\n");
   return work_stmt;
 }

References call_STEP_subroutine2(), insert_statement(), pips_debug, and RT_STEP_barrier.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compile_body()

static void compile_body	(	statement	directive_stmt,
		entity	new_module,
		step_directive	drt,
		int	transformation,
		list	referenced_entities,
		statement	new_body,
		statement	mpi_begin_stmt,
		statement	work_stmt,
		statement	mpi_end_stmt
	)

static

Definition at line 331 of file compile_mpi.c.

 {
   bool loop_p = false;
   set reductions_l[STEP_UNDEF_REDUCE];
   bool reduction_p = false;
  
   assert(!entity_undefined_p(get_current_module_entity()));
  
   statement_effects send_regions = (statement_effects)db_get_memory_resource(DBR_STEP_SEND_REGIONS, get_current_module_name(), true);
   list send_l =  duplicate_regions_referenced_entity(referenced_entities, effects_effects(apply_statement_effects(send_regions, directive_stmt)));
   statement_effects recv_regions = (statement_effects)db_get_memory_resource(DBR_STEP_RECV_REGIONS, get_current_module_name(), true);
   list recv_l =  duplicate_regions_referenced_entity(referenced_entities, effects_effects(apply_statement_effects(recv_regions, directive_stmt)));
  
  
   pips_assert("step_directive_type(drt)",
               step_directive_type(drt) == STEP_PARALLEL ||
               step_directive_type(drt) == STEP_PARALLEL_DO ||
               step_directive_type(drt) == STEP_DO ||
               step_directive_type(drt) == STEP_MASTER ||
               step_directive_type(drt) == STEP_BARRIER ||
               step_directive_type(drt) == STEP_THREADPRIVATE);
  
   step_directive_type_print(drt);
  
   loop loop_stmt = loop_undefined;
  
   if (step_directive_type(drt) == STEP_PARALLEL)
     {
       generate_call_init_regionArray(referenced_entities, mpi_begin_stmt, mpi_end_stmt);
     }
   if (step_directive_type(drt) == STEP_PARALLEL_DO)
     {
       list l = keep_recv_or_send_referenced_entity(recv_l, send_l, referenced_entities);
       generate_call_init_regionArray(l, mpi_begin_stmt, mpi_end_stmt);
       gen_free_list(l);
     }
  
   if (step_directive_type(drt) == STEP_PARALLEL_DO || step_directive_type(drt) == STEP_DO)
     {
       statement loopslices_stmt = statement_undefined;
       list work_block = statement_block(work_stmt);
  
       loop_stmt = statement_loop(STATEMENT(CAR(statement_block(STATEMENT(CAR(work_block))))));
       loop_p = true;
  
       pips_debug(2, "loop_stmt = %p\n", loop_stmt);
  
       loopslices_stmt = compile_loopslices(new_module, loop_stmt);
       insert_statement(mpi_begin_stmt, loopslices_stmt, false);
  
       loopbounds_substitution(new_module, loop_stmt);
       work_stmt = compile_loopbounds(new_module, loop_stmt, work_stmt);
       loop_basic_workchunk_to_workchunk(directive_stmt, &recv_l, &send_l);
     }
  
  
   if (step_directive_type(drt) ==  STEP_MASTER)
     {
       work_stmt = compile_master(new_module, work_stmt);
     }
  
   if (step_directive_type(drt) ==  STEP_BARRIER)
     {
       work_stmt = compile_barrier(new_module, work_stmt);
     }
  
   reduction_p = step_get_directive_reductions(drt, reductions_l);
   if (reduction_p)
     compile_reduction(reductions_l, mpi_begin_stmt, mpi_end_stmt);
  
   if (recv_l != NIL)
     {
       pips_debug(2, "compile RECV regions\n");
       list send_as_comm_l = list_undefined;
       compile_regions(new_module, recv_l, loop_p, loop_stmt, send_as_comm_l, reductions_l, mpi_begin_stmt, mpi_end_stmt);
     }
  
   if (send_l != NIL)
     {
       pips_debug(2, "compile SEND regions\n");
       list send_as_comm_l = effects_effects(apply_statement_effects(send_regions, directive_stmt));
       compile_regions(new_module, send_l, loop_p, loop_stmt, send_as_comm_l, reductions_l, mpi_begin_stmt, mpi_end_stmt);
     }
  
   generate_call_construct_begin_construct_end(new_module, drt, mpi_begin_stmt, mpi_end_stmt);
  
   ifdebug(2)
     {
       pips_debug(2, "mpi_begin_stmt\n");
       print_statement(mpi_begin_stmt);
       pips_debug(2, "mpi_end_stmt\n");
       print_statement(mpi_end_stmt);
     }
  
   /*
     Body building
   */
   statement begin_work_stmt = make_plain_continue_statement();
   statement end_work_stmt = make_plain_continue_statement();
   put_a_comment_on_a_statement(begin_work_stmt, strdup("\nBEGIN WORK"));
   put_a_comment_on_a_statement(end_work_stmt, strdup("END WORK\n"));
   insert_statement(work_stmt, begin_work_stmt, true);
   insert_statement(work_stmt, end_work_stmt, false);
   insert_statement(new_body, work_stmt, false);
  
   if (transformation == STEP_TRANSFORMATION_HYBRID &&
       step_directive_type(drt) != STEP_MASTER)
     {
       compile_omp(directive_stmt, drt);
       add_omp_guard(&mpi_begin_stmt);
       add_omp_guard(&mpi_end_stmt);
     }
  
  
   if(!empty_statement_p(mpi_begin_stmt))
     insert_statement(new_body, mpi_begin_stmt, true);
   if(!empty_statement_p(mpi_end_stmt))
     insert_statement(new_body, mpi_end_stmt, false);
  
   if (transformation == STEP_TRANSFORMATION_HYBRID &&
       step_directive_type(drt) == STEP_MASTER)
     {
       add_omp_guard(&new_body);
     }
 }

References add_omp_guard(), apply_statement_effects(), assert, CAR, compile_barrier(), compile_loopbounds(), compile_loopslices(), compile_master(), compile_omp(), compile_reduction(), compile_regions(), db_get_memory_resource(), duplicate_regions_referenced_entity(), effects_effects, empty_statement_p(), entity_undefined_p, gen_free_list(), generate_call_construct_begin_construct_end(), generate_call_init_regionArray(), get_current_module_entity(), get_current_module_name(), ifdebug, insert_statement(), keep_recv_or_send_referenced_entity(), list_undefined, loop_basic_workchunk_to_workchunk(), loop_undefined, loopbounds_substitution(), make_plain_continue_statement(), NIL, pips_assert, pips_debug, print_statement(), put_a_comment_on_a_statement(), reduction_p(), STATEMENT, statement_block(), statement_loop(), statement_undefined, STEP_BARRIER, step_directive_type, step_directive_type_print(), STEP_DO, step_get_directive_reductions(), STEP_MASTER, STEP_PARALLEL, STEP_PARALLEL_DO, STEP_THREADPRIVATE, STEP_TRANSFORMATION_HYBRID, STEP_UNDEF_REDUCE, and strdup().

Referenced by compile_mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compile_loopbounds()

static statement compile_loopbounds	(	entity	new_module,
		loop	loop_stmt,
		statement	work_stmt
	)

static

Definition at line 51 of file compile_mpi.c.

 {
   statement stmt;
   statement rank_stmt; 
   statement get_loopbounds_stmt;
   pips_debug(1, "begin\n");
  
  
   rank_stmt = generate_call_get_rank(new_module);
   get_loopbounds_stmt = generate_call_get_rank_loopbounds(new_module, loop_stmt);
  
   stmt = make_block_statement(make_statement_list(rank_stmt, get_loopbounds_stmt, work_stmt));
  
   pips_debug(1, "end\n");
   return stmt;
 }

References generate_call_get_rank(), generate_call_get_rank_loopbounds(), make_block_statement(), make_statement_list, and pips_debug.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compile_loopslices()

static statement compile_loopslices	(	entity	new_module,
		loop	loop_stmt
	)

static

Definition at line 36 of file compile_mpi.c.

 {
   statement stmt;
   statement commsize_stmt;
   statement loopslice_stmt;
   pips_debug(1, "begin new_module = %p, loop_stmt = %p\n", new_module, loop_stmt);
  
   commsize_stmt = generate_call_get_commsize(new_module);
   loopslice_stmt = generate_call_compute_loopslices(new_module, loop_stmt);
  
   stmt = make_block_statement(make_statement_list(commsize_stmt, loopslice_stmt));
   pips_debug(1, "end\n");
   return stmt;
 }

References generate_call_compute_loopslices(), generate_call_get_commsize(), make_block_statement(), make_statement_list, and pips_debug.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compile_master()

static statement compile_master	(	entity	new_module,
		statement	work_stmt
	)

static

Definition at line 205 of file compile_mpi.c.

 {
   statement stmt;
   pips_debug(1, "begin\n");
  
   entity rank = get_entity_step_rank(new_module);
   expression expr_rank = entity_to_expression(rank);
  
  
   /*
     Generation of
     STEP_GET_RANK(&STEP_COMM_RANK);
   */
   statement rank_stmt = call_STEP_subroutine2(RT_STEP_get_rank, get_expression_addr(expr_rank), NULL);
  
   /*
     Generation of
     if (STEP_COMM_RANK==0) {}
   */
   statement if_stmt = instruction_to_statement(make_instruction_test(make_test(MakeBinaryCall(entity_intrinsic(EQUAL_OPERATOR_NAME),
                                                                                               expr_rank,
                                                                                               int_to_expression(0)),
                                                                                work_stmt, make_block_statement(NIL))));
  
   stmt = make_block_statement(make_statement_list(rank_stmt, if_stmt));
  
   pips_debug(1, "end\n");
   return stmt;
 }

References call_STEP_subroutine2(), entity_intrinsic(), entity_to_expression(), EQUAL_OPERATOR_NAME, get_entity_step_rank(), get_expression_addr(), instruction_to_statement(), int_to_expression(), make_block_statement(), make_instruction_test(), make_statement_list, make_test(), MakeBinaryCall(), NIL, pips_debug, rank, and RT_STEP_get_rank.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compile_mpi()

statement compile_mpi	(	statement	directive_stmt,
		string	new_module_name,
		step_directive	drt,
		int	transformation
	)

compile_mpi.c

Parameters

directive_stmt	irective_stmt
new_module_name	ew_module_name
drt	rt
transformation	ransformation

Definition at line 517 of file compile_mpi.c.

 {
   pips_debug(1, "begin current module %p : %s\n", get_current_module_entity(), get_current_module_name());
  
   list statements_to_outline = make_statement_list(directive_stmt);
   entity new_module = gen_find_tabulated(concatenate(TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING, new_module_name, NULL), entity_domain);
   pips_assert("new_module", !entity_undefined_p(new_module));
  
   // Init hash table
   hash_table entity_to_effective_parameter = outliner_init(new_module, statements_to_outline);
  
   // Find referenced entities in statements_to_outline
   statement new_body = make_empty_block_statement();
   list referenced_entities = outliner_scan(new_module, statements_to_outline, new_body);
  
   // Generate the body of the new module
   statement work_stmt = make_block_statement(gen_copy_seq(statements_to_outline));
   statement mpi_begin_stmt = make_empty_block_statement();
   statement mpi_end_stmt = make_empty_block_statement();
   compile_body(directive_stmt, new_module, drt, transformation, referenced_entities, new_body, mpi_begin_stmt, work_stmt, mpi_end_stmt);
  
   // Some entities may be added by region_to_statement. Ensure they will be passed as parameters
   update_referenced_entities(new_body, &referenced_entities);
  
   // Update hash table and build parameters
   list effective_parameters = NIL, formal_parameters = NIL;
   outliner_parameters(new_module, new_body, referenced_entities, entity_to_effective_parameter, &effective_parameters, &formal_parameters);
  
   // Patch parameters for side effects
   if(c_module_p(get_current_module_entity()))
     outliner_patch_parameters(statements_to_outline, referenced_entities, effective_parameters, formal_parameters, new_body, mpi_begin_stmt, mpi_end_stmt);
  
   step_RT_set_local_declarations(new_module, new_body);
  
   // Source file generation
   set_prettyprinter_head_hook(step_head_hook);
   outliner_file(new_module, formal_parameters, &new_body);
   reset_prettyprinter_head_hook();
  
   step_RT_clean_local();
  
   statement call_stmt = outliner_call(new_module, statements_to_outline, effective_parameters);
  
   pips_debug(1, "end\n");
   return call_stmt;
 }

References c_module_p(), compile_body(), concatenate(), entity_domain, entity_undefined_p, gen_copy_seq(), gen_find_tabulated(), get_current_module_entity(), get_current_module_name(), make_block_statement(), make_empty_block_statement(), make_statement_list, MODULE_SEP_STRING, NIL, outliner_call(), outliner_file(), outliner_init(), outliner_parameters(), outliner_patch_parameters(), outliner_scan(), pips_assert, pips_debug, reset_prettyprinter_head_hook(), set_prettyprinter_head_hook(), step_head_hook(), step_RT_clean_local(), step_RT_set_local_declarations(), TOP_LEVEL_MODULE_NAME, and update_referenced_entities().

Referenced by compile_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compile_reduction()

static void compile_reduction	(	set	reductions_l[STEP_UNDEF_REDUCE],
		statement	before_stmt,
		statement	after_stmt
	)

static

Definition at line 68 of file compile_mpi.c.

 {
   int op;
   string op_name[STEP_UNDEF_REDUCE]={STEP_PROD_REDUCE_NAME, STEP_MAX_REDUCE_NAME, STEP_MIN_REDUCE_NAME, STEP_SUM_REDUCE_NAME};
  
   pips_debug(1, "begin\n");
  
   pips_assert("block before", !statement_undefined_p(before_stmt) && statement_block_p(before_stmt));
   pips_assert("block after", !statement_undefined_p(after_stmt) && statement_block_p(after_stmt));
  
   for (op = 0; op < STEP_UNDEF_REDUCE; op++)
     if (!set_empty_p(reductions_l[op]))
       {
         FOREACH(ENTITY, variable, set_to_sorted_list(reductions_l[op], (gen_cmp_func_t)compare_entities))
           {
             expression variable_expr, variable_type_expr;
             statement reduction_init_stmt;
             /*
               Generation of
               STEP_INITREDUCTION(&sum, STEP_SUM, STEP_INTEGER4);
              */
  
             check_entity_step_type(variable);
  
             variable_expr = entity_to_expression(variable);
             variable_type_expr = entity_to_expression(step_type(variable));
             reduction_init_stmt = call_STEP_subroutine2(RT_STEP_initreduction, get_expression_addr(variable_expr), entity_to_expression(MakeConstant(op_name[op], is_basic_string)), variable_type_expr, NULL);
  
             insert_statement(before_stmt,
                              reduction_init_stmt, false);
  
             /*
               Generation of
               STEP_REDUCTION(&sum);
             */
  
             /*
             list arglist = CONS(EXPRESSION, variable_expr,
                            CONS(EXPRESSION, entity_to_expression(MakeConstant(op_name[op], is_basic_string)),
                                 NIL));
             insert_statement(before_stmt,
                              call_STEP_subroutine(RT_STEP_initreduction, arglist, variable), false);
             */
                              
             insert_statement(after_stmt,
                              call_STEP_subroutine2(RT_STEP_reduction, get_expression_addr(variable_expr), NULL), false);
           }
       }
  
   pips_debug(1, "end\n");
 }

References call_STEP_subroutine2(), check_entity_step_type(), compare_entities(), ENTITY, entity_to_expression(), FOREACH, get_expression_addr(), insert_statement(), is_basic_string, MakeConstant(), pips_assert, pips_debug, RT_STEP_initreduction, RT_STEP_reduction, set_empty_p(), set_to_sorted_list(), statement_block_p, statement_undefined_p, STEP_MAX_REDUCE_NAME, STEP_MIN_REDUCE_NAME, STEP_PROD_REDUCE_NAME, STEP_SUM_REDUCE_NAME, step_type(), and STEP_UNDEF_REDUCE.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ duplicate_regions_referenced_entity()

static list duplicate_regions_referenced_entity	(	list	referenced_entities,
		list	regions_l
	)

static

Definition at line 288 of file compile_mpi.c.

 {
   list l = NIL;
  
   FOREACH(REGION, reg, regions_l)
     {
       if (gen_in_list_p(region_entity(reg), referenced_entities))
         l = CONS(REGION, copy_effect(reg), l);
       else
         pips_debug(2,"drop entity %s not in referenced_entities\n", entity_name(region_entity(reg)));
     }
   return gen_nreverse(l);
 }

References CONS, copy_effect(), entity_name, FOREACH, gen_in_list_p(), gen_nreverse(), NIL, pips_debug, REGION, and region_entity.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ keep_recv_or_send_referenced_entity()

static list keep_recv_or_send_referenced_entity	(	list	recv_l,
		list	send_l,
		list	referenced_entities
	)

static

Definition at line 302 of file compile_mpi.c.

 {
    list l = NIL;
    set recv_s = set_make(set_pointer);
    set send_s = set_make(set_pointer);
  
    FOREACH(REGION, r, recv_l)
      {
        recv_s = set_add_element(recv_s, recv_s, region_entity(r));
      }
    FOREACH(REGION, r, send_l)
      {
        send_s = set_add_element(send_s, send_s, region_entity(r));
      }
  
    FOREACH(ENTITY, e, referenced_entities)
      {
        if (set_belong_p(recv_s, e) || set_belong_p(send_s, e))
          l = CONS(ENTITY, e, l);
        else
          pips_debug(2, "entity %s in referenced entities but not in recv nor send regions\n", entity_name(e));
      }
  
    set_free(recv_s);
    set_free(send_s);
  
   return gen_nreverse(l);
 }

References CONS, ENTITY, entity_name, FOREACH, gen_nreverse(), NIL, pips_debug, REGION, region_entity, set_add_element(), set_belong_p(), set_free(), set_make(), and set_pointer.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loop_basic_workchunk_to_workchunk()

static void loop_basic_workchunk_to_workchunk	(	statement	stmt,
		list *	recv_l,
		list *	send_l
	)

static

find the real upper and lower bounds

Definition at line 125 of file compile_mpi.c.

 {
   pips_debug(1, "begin\n");
   list dir_block = statement_block(stmt);
   loop l = statement_loop(STATEMENT(CAR(dir_block)));
   entity index = loop_index(l);
   range r = loop_range(l);
  
   /* find the real upper and lower bounds */
   int incr_lb = 0;
   int incr_ub = 0;
   expression e_incr = range_increment(r);
   transformer loop_prec = make_transformer(NIL, make_predicate((Psysteme)sc_rn((Pbase)vect_new((Variable)index, VALUE_ONE))));
   // is the loop increment numerically known? Is its sign known?
   expression_and_precondition_to_integer_interval(e_incr, loop_prec, &incr_lb, &incr_ub);
  
   int incr = 0;
   if (incr_lb == incr_ub) {
     if (incr_lb == 0) {
       pips_user_error("Illegal null increment\n");
     }
     else
       incr = incr_lb;
   }
   else if (incr_lb >= 1) {
     incr = 1;
   }
   else if (incr_ub <= -1) {
     incr = -1;
   }
   entity e_lb = step_local_loop_index(get_current_module_entity(), strdup(STEP_BOUNDS_LOW(index)));
   entity e_ub = step_local_loop_index(get_current_module_entity(), strdup(STEP_BOUNDS_UP(index)));
  
   // to check later in update_referenced_entities
   set_add_element(step_created_entity, step_created_entity, e_lb);
   set_add_element(step_created_entity, step_created_entity, e_ub);
  
   if (incr < 0)
     {
       entity tmp = e_lb;
       e_lb = e_ub;
       e_ub = tmp;
     }
   /*
     Add constraints
     Projection
   */
   Psysteme sc_bounds = sc_new();
   // contrainte lb - index <= 0
   insert_ineq_begin_sc(sc_bounds, contrainte_make(vect_make(VECTEUR_NUL, (Variable)e_lb, VALUE_ONE, (Variable)index, VALUE_MONE, TCST, VALUE_ZERO)));
   // contrainte index - ub <= 0
   insert_ineq_begin_sc(sc_bounds, contrainte_make(vect_make(VECTEUR_NUL, (Variable)index, VALUE_ONE, (Variable)e_ub, VALUE_MONE, TCST, VALUE_ZERO)));
   sc_creer_base(sc_bounds);
  
   *send_l = all_regions_sc_append(*send_l, sc_bounds, true);
   *recv_l = all_regions_sc_append(*recv_l, sc_bounds, true);
   project_regions_along_variables(*send_l, CONS(entity, index, NIL));
   project_regions_along_variables(*recv_l, CONS(entity, index, NIL));
  
   FOREACH(REGION, reg, *send_l)
     {
       rectangularization_region(reg);
     }
   FOREACH(REGION, reg, *recv_l)
     {
       rectangularization_region(reg);
     }
  
   ifdebug(1)
     {
       pips_debug(1, "SEND after projection and rectangularization : \n");
       print_rw_regions(*send_l);
       pips_debug(1, "RECV after projection and rectangularization : \n");
       print_rw_regions(*recv_l);
     }
  
   pips_debug(1, "end\n");
 }

References all_regions_sc_append(), CAR, CONS, contrainte_make(), expression_and_precondition_to_integer_interval(), FOREACH, get_current_module_entity(), ifdebug, insert_ineq_begin_sc(), loop_index, loop_range, make_predicate(), make_transformer(), NIL, pips_debug, pips_user_error, print_rw_regions(), project_regions_along_variables(), range_increment, rectangularization_region(), REGION, sc_creer_base(), sc_new(), sc_rn(), set_add_element(), STATEMENT, statement_block(), statement_loop(), STEP_BOUNDS_LOW, STEP_BOUNDS_UP, step_created_entity, step_local_loop_index(), strdup(), TCST, VALUE_MONE, VALUE_ONE, VALUE_ZERO, vect_make(), vect_new(), and VECTEUR_NUL.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loopbounds_substitution()

static void loopbounds_substitution	(	entity	new_module,
		loop	loop_stmt
	)

static

Definition at line 27 of file compile_mpi.c.

 {
   entity index = loop_index(loop_stmt);
   range r = loop_range(loop_stmt);
  
   range_lower(r) = entity_to_expression(step_local_loop_index(new_module, STEP_BOUNDS_LOW(index)));
   range_upper(r) = entity_to_expression(step_local_loop_index(new_module, STEP_BOUNDS_UP(index)));
 }

References entity_to_expression(), loop_index, loop_range, range_lower, range_upper, STEP_BOUNDS_LOW, STEP_BOUNDS_UP, and step_local_loop_index().

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ step_get_directive_reductions()

static bool step_get_directive_reductions	(	step_directive	drt,
		set *	reductions_l
	)

static

Definition at line 246 of file compile_mpi.c.

 {
   bool reduction_p = false;
   int op;
  
   pips_debug(1, "begin\n");
  
   for(op = 0; op < STEP_UNDEF_REDUCE; op++)
     reductions_l[op] = set_make(set_pointer);
  
   FOREACH(STEP_CLAUSE, c, step_directive_clauses(drt))
     {
       switch (step_clause_tag(c))
         {
         case is_step_clause_reduction:
           MAP_ENTITY_INT_MAP(variable, op, {
               set_add_element(reductions_l[op], reductions_l[op], variable);
               reduction_p = true;
             }, step_clause_reduction(c));
           break;
         case is_step_clause_transformation:
         case is_step_clause_nowait:
         case is_step_clause_private:
         case is_step_clause_shared:
         case is_step_clause_threadprivate:
         case is_step_clause_firstprivate:
         case is_step_clause_copyin:
         case is_step_clause_schedule:
           break;
         default: pips_assert("clause not compiled", 0);
         }
     }
  
   pips_debug(1, "end\n");
   return reduction_p;
 }

References FOREACH, is_step_clause_copyin, is_step_clause_firstprivate, is_step_clause_nowait, is_step_clause_private, is_step_clause_reduction, is_step_clause_schedule, is_step_clause_shared, is_step_clause_threadprivate, is_step_clause_transformation, MAP_ENTITY_INT_MAP, pips_assert, pips_debug, reduction_p(), set_add_element(), set_make(), set_pointer, STEP_CLAUSE, step_clause_reduction, step_clause_tag, step_directive_clauses, and STEP_UNDEF_REDUCE.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ step_head_hook()

static string step_head_hook ( entity __attribute__((unused)) e )

static

This file is part of STEP.

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

Definition at line 20 of file compile_mpi.c.

 {
   return strdup(concatenate
                 ("      implicit none\n",
                  "      include \"STEP.h\"\n", NULL));
 }

References concatenate(), and strdup().

Referenced by compile_mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_referenced_entities()

static void update_referenced_entities	(	statement	new_body,
		list *	referenced_entities
	)

static

Definition at line 459 of file compile_mpi.c.

 {
   int local_dbg_lvl = 2;
   set new_entities = set_make(set_pointer);
   list l_body = make_statement_list(new_body);
  
   set_assign_list(new_entities, outliner_statements_referenced_entities(l_body));
  
   if(!set_undefined_p(step_created_symbolic))
     {
       SET_FOREACH(entity, step_symbolic_e, step_created_symbolic)
         {
           pips_debug(local_dbg_lvl, "drop entities step_symbolic : %s\n", entity_name(step_symbolic_e));
           new_entities = set_del_element(new_entities, new_entities, step_symbolic_e);
         }
     }
  
   FOREACH(ENTITY, e, *referenced_entities)
     {
       pips_debug(local_dbg_lvl, "drop referenced entity : %s\n", entity_name(e));
       new_entities = set_del_element(new_entities, new_entities, e);
     }
  
   if(step_created_entity != set_undefined)
     {
       SET_FOREACH(entity, created_e, step_created_entity)
         {
           pips_debug(local_dbg_lvl, "drop entities step_created : %s\n", entity_name(created_e));
           new_entities = set_del_element(new_entities, new_entities, created_e);
         }
     }
  
   FOREACH(ENTITY, e, statements_to_declarations(l_body))
     {
       pips_debug(local_dbg_lvl, "drop declared entity : %s\n", entity_name(e));
       new_entities = set_del_element(new_entities, new_entities, e);
     }
  
   if(c_module_p(get_current_module_entity()))
     {
       FOREACH(ENTITY, e, entity_declarations(module_name_to_entity(compilation_unit_of_module(get_current_module_name()))))
         {
           if(top_level_entity_p(e) && set_belong_p(new_entities, e))
             {
               pips_debug(local_dbg_lvl, "drop global entity : %s\n", entity_name(e));
               new_entities = set_del_element(new_entities, new_entities, e);
             }
         }
     }
  
   list new_e = set_to_sorted_list(new_entities, (gen_cmp_func_t)compare_entities);
   set_free(new_entities);
  
   pips_debug(local_dbg_lvl, "New entities : "); print_entities(new_e); fprintf(stderr, "\n\n");
  
   *referenced_entities = gen_nconc(*referenced_entities, new_e);
 }

References c_module_p(), compare_entities(), compilation_unit_of_module(), ENTITY, entity_declarations, entity_name, FOREACH, fprintf(), gen_nconc(), get_current_module_entity(), get_current_module_name(), make_statement_list, module_name_to_entity(), outliner_statements_referenced_entities(), pips_debug, print_entities(), set_assign_list(), set_belong_p(), set_del_element(), SET_FOREACH, set_free(), set_make(), set_pointer, set_to_sorted_list(), set_undefined, set_undefined_p, statements_to_declarations(), step_created_entity, step_created_symbolic, and top_level_entity_p().

Referenced by compile_mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Function Documentation

◆ compile_barrier()

◆ compile_body()

◆ compile_loopbounds()

◆ compile_loopslices()

◆ compile_master()

◆ compile_mpi()

◆ compile_reduction()

◆ duplicate_regions_referenced_entity()

◆ keep_recv_or_send_referenced_entity()

◆ loop_basic_workchunk_to_workchunk()

◆ loopbounds_substitution()

◆ step_get_directive_reductions()

◆ step_head_hook()

◆ update_referenced_entities()