copy_value_of_write.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "resources.h"
#include "database.h"
#include "ri.h"
#include "ri-util.h"
#include "effects.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "control.h"
#include "misc.h"
#include "properties.h"
#include "conversion.h"
#include "task_parallelization.h"
#include "prettyprint.h"
#include "workspace-util.h"

Include dependency graph for copy_value_of_write.c:

Go to the source code of this file.

Functions
static string	copy_variable_declaration_commenter (__attribute__((unused)) entity e)
	Pass: COPY_VALUE_OF_WRITE Debug mode: MPI_GENERATION_DEBUG_LEVEL Properties used: More...
static void	statement_convert_to_statement_with_sequence_of_intruction (statement s, bool extensions_on_sequence)
	Maybe these function can be move in statement.c? More...
static bool	statement_with_side_effect_p (statement s)
	statement_with_side_effect_p Check if the statement make side effect in a variable a side effect for a statement is defined by doing a read and a write on the same variable for the statement More...
static entity	region_entity_variable_to_new_declare_entity (entity ent, int taskid)
	translate an entity region in a variable entity if it's need if ent is an entity region return a variable entity else ent is already a variable entity so just return ent More...
static void	translate_reference_region (reference ref, int *taskid)
	call with gen_recurse modify by side effect the variable of the reference to be sure to be a variable entity and not a region entity in some cases More...
static statement	make_statement_copy_i (reference ref, int i, int taskid)
	make_statement_copy_i generate a copy_statement with ref, generate a statement: ref_i = ref; More...
static void	copy_n_statement (list lweffects, int nbr, statement st)
	copy_n_statement generate and add nbr statements of copy with reference ref, we have the variable that has a write effect and make some copy for the variables on the other proc example: lhs = rhs; ----—> lhs_0 = rhs; lhs_1 = rhs; ... More...
static void	copy_n_reference (reference ref, int nbr, statement st)
	copy_n_reference generate and add nbr statements of copy with reference ref, we have the variable that has a write effect and make some copy for the variables on the other proc example: lhs = rhs; ----—> lhs = rhs; lhs_0 = lhs; lhs_1 = lhs; ... More...
static void	copy_write_statement (statement s)
	copy_write_statement for the statement s, check if there is/are write effect foreach write effect make a copy statement for the variable written on there equivalent for each cluster. More...
bool	copy_value_of_write (const char *module_name)
	PIPS pass. More...
static void	copy_write_statement_with_cumulated_regions (statement module_statement)
	copy_write_statement_with_cumulated_regions foreach first level statement in module_statement generate copies for variables present in out-region if it's an array region, generate variable for indices More...
bool	copy_value_of_write_with_cumulated_regions (const char *module_name)
	PIPS pass. More...

Function Documentation

copy_n_reference()

static void copy_n_reference ( reference  ref, int  nbr, statement  st  )

static

copy_n_reference generate and add nbr statements of copy with reference ref, we have the variable that has a write effect and make some copy for the variables on the other proc example: lhs = rhs; ----—> lhs = rhs; lhs_0 = lhs; lhs_1 = lhs; ...

Parameters

ref	reference of the variable written
nbr	number of copy wanted (number of proc asked)
st	statement after which we make the copy/ statement which has a write effect

TODO tester si side effect dans les subscripte si oui renvoyer erreur faire pass pour extraire side-effect des subscript si possible existe déjà?

Definition at line 432 of file copy_value_of_write.c.

                                                                   {
  pips_assert("statement st is consistent", statement_consistent_p(st));
  //entity var = reference_variable(ref);
  list indices = reference_indices(ref);
  task t = load_parallel_task_mapping(st);
  ifdebug(2) {
    pips_debug(2, "begin\n");
    pips_debug(2, "statement with : \n");
    print_statement(st);
  }
 
  if (indices != NIL) {
    FOREACH(EXPRESSION, index, indices) {
      if (expression_with_side_effect_p(index)) {
        /* TODO tester si side effect dans les subscripte
         * si oui renvoyer erreur
         * faire pass pour extraire side-effect des subscript si possible
         * existe déjà?
         */
        pips_user_warning("presence of side effect in subscript expression %p : %s\n"
            "Result of this pass can be false\n", index, expression_to_string(index));
      }
    }
  }
 
  // if the statement st have a pragma and it's not a block
  // we convert st to a block statement
  // if we don't make the convertion, the copy statement won't be affect by the pragma
  // another possible solution is to add the pragma for the copy statement
  if (//statement_with_pragma_p(st) &&  //because of the mapping of the resource have to always doing it to update mapping of statement
      !instruction_sequence_p(statement_instruction(st))) {
    statement_convert_to_statement_with_sequence_of_intruction(st, true);
    pips_assert("statement st is consistent", statement_consistent_p(st));
    store_or_update_parallel_task_mapping(STATEMENT(CAR(sequence_statements(instruction_sequence(statement_instruction(st))))), t);
  }
 
  statement scopy = statement_undefined;
 
  //Make copy for each cluster
  for (int i=0; i<nbr; i++) {
    scopy = make_statement_copy_i(ref, i, task_id(t));
    pips_assert("statement scopy is consistent", statement_consistent_p(scopy));
    store_or_update_parallel_task_mapping(scopy, t);
 
    insert_statement(st, scopy, false);
    pips_assert("statement st is consistent", statement_consistent_p(st));
 
    scopy = statement_undefined;
  }
 
  ifdebug(5) {
    pips_debug(5, "statement with : \n");
    print_statement(st);
    pips_debug(5, "end\n");
  }
}

References CAR, EXPRESSION, expression_to_string(), expression_with_side_effect_p(), FOREACH, ifdebug, indices, insert_statement(), instruction_sequence, instruction_sequence_p, load_parallel_task_mapping(), make_statement_copy_i(), NIL, pips_assert, pips_debug, pips_user_warning, print_statement(), ref, reference_indices, sequence_statements, STATEMENT, statement_consistent_p(), statement_convert_to_statement_with_sequence_of_intruction(), statement_instruction, statement_undefined, store_or_update_parallel_task_mapping(), and task_id.

Referenced by copy_write_statement(), and copy_write_statement_with_cumulated_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_n_statement()

static void copy_n_statement ( list  lweffects, int  nbr, statement  st  )

static

copy_n_statement generate and add nbr statements of copy with reference ref, we have the variable that has a write effect and make some copy for the variables on the other proc example: lhs = rhs; ----—> lhs_0 = rhs; lhs_1 = rhs; ...

Parameters

nbr	number of copy wanted (number of proc asked)
st	statement after which we make the copy/ statement which has a write effect

Definition at line 336 of file copy_value_of_write.c.

                                                                    {
  pips_assert("statement st is consistent", statement_consistent_p(st));
  ifdebug(2) {
    pips_debug(2, "begin\n");
    pips_debug(2, "statement with : \n");
    print_statement(st);
  }
 
  task t = load_parallel_task_mapping(st);
 
  if (statement_with_side_effect_p(st)) {
    pips_user_warning("statement %s, have side effect.\n"
        "The result of the generated code can be wrong without no other pass transformation.\n"
        "Need to execute ELIMINATE_ORIGINAL_VARIABLE\n", statement_identification(st));
  }
 
  list lstatement = NIL;
 
  for (int i=0; i<nbr; i++) {
    statement sti;
    task new_task = make_task(
        task_id(t),
        task_private_data(t),
        i,
        task_synchronization(t)
        );
 
    sti = copy_statement(st);
    store_or_update_parallel_task_mapping(sti, new_task);
    ifdebug(3) {
      print_statement(sti);
    }
 
    if (//statement_with_pragma_p(sti) &&  //because of the mapping of the resource have to always doing it to update mapping of statement
        !instruction_sequence_p(statement_instruction(sti))) {
      statement_convert_to_statement_with_sequence_of_intruction(sti, false);
      pips_assert("statement sti is consistent", statement_consistent_p(sti));
      store_or_update_parallel_task_mapping(STATEMENT(CAR(sequence_statements(instruction_sequence(statement_instruction(sti))))), new_task);
    }
    statement scopy = statement_undefined;
    FOREACH(EFFECT, we, lweffects) {
      reference wref = effect_any_reference(we);
      entity went = reference_variable(wref);
      if(!effects_package_entity_p(went)
          && !ENTITY_STDERR_P(went) && !ENTITY_STDIN_P(went) && !ENTITY_STDOUT_P(went)) {
        scopy = make_statement_copy_i(wref, i, task_id(t));
        pips_assert("statement scopy is consistent", statement_consistent_p(scopy));
        store_or_update_parallel_task_mapping(scopy, new_task);
 
        insert_statement(sti, scopy, false);
        pips_assert("statement sti is consistent", statement_consistent_p(sti));
        scopy = statement_undefined;
      }
    }
    lstatement = CONS(STATEMENT, sti, lstatement);
  }
 
  if (!ENDP(lstatement)) {
    statement_label(st)=entity_empty_label();
    statement_number(st)=STATEMENT_NUMBER_UNDEFINED;
    statement_ordering(st)=STATEMENT_ORDERING_UNDEFINED;
    statement_comments(st)=string_undefined;
    statement_instruction(st)=instruction_undefined;
    statement_declarations(st)=NIL;
    statement_decls_text(st)=NULL;
    statement_extensions(st) = empty_extensions();
    //statement_synchronization(s) = make_synchronization_none();
 
    statement_instruction(st) =  make_instruction_sequence(make_sequence(lstatement));
  }
  else {
    pips_internal_error("Normally never appear.");
  }
 
  ifdebug(2) {
    pips_debug(2, "statement with : \n");
    print_statement(st);
    pips_debug(2, "end\n");
  }
}

References CAR, CONS, copy_statement(), EFFECT, effect_any_reference, effects_package_entity_p(), empty_extensions(), ENDP, entity_empty_label(), ENTITY_STDERR_P, ENTITY_STDIN_P, ENTITY_STDOUT_P, FOREACH, ifdebug, insert_statement(), instruction_sequence, instruction_sequence_p, instruction_undefined, load_parallel_task_mapping(), make_instruction_sequence(), make_sequence(), make_statement_copy_i(), make_task(), NIL, pips_assert, pips_debug, pips_internal_error, pips_user_warning, print_statement(), reference_variable, sequence_statements, STATEMENT, statement_comments, statement_consistent_p(), statement_convert_to_statement_with_sequence_of_intruction(), statement_declarations, statement_decls_text, statement_extensions, statement_identification(), statement_instruction, statement_label, statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, STATEMENT_ORDERING_UNDEFINED, statement_undefined, statement_with_side_effect_p(), store_or_update_parallel_task_mapping(), string_undefined, task_id, task_private_data, and task_synchronization.

Referenced by copy_write_statement(), and copy_write_statement_with_cumulated_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_value_of_write()

bool copy_value_of_write

(

const char *

module_name

)

PIPS pass.

copy_value_of_write.c

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 542 of file copy_value_of_write.c.

                                                  {
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
//  if(use_points_to) {
//    set_pointer_info_kind(with_points_to); //enough?
//  }
  set_proper_rw_effects((statement_effects)
      db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects)
      db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
 
  //-- Make the job -- //
  gen_recurse(module_statement, statement_domain, gen_true, copy_write_statement);
//  gen_recurse(module_statement, statement_domain, copy_write_statement, gen_true);
//  if(use_points_to) {
//    //TODO
//    //gen_recurse(module_statement, statement_domain, gen_true, identity_statement_remove_with_points_to);
//  }
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  // Removed useless block created by the insert_statement
  unspaghettify_statement(module_statement);
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
  DB_PUT_MEMORY_RESOURCE(DBR_TASK, module_name, get_parallel_task_mapping());
 
  reset_ordering_to_statement();
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References copy_write_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), get_current_module_statement(), get_parallel_task_mapping(), module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_parallel_task_mapping(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_parallel_task_mapping(), set_proper_rw_effects(), statement_consistent_p(), statement_domain, strdup(), and unspaghettify_statement().

Here is the call graph for this function:

copy_value_of_write_with_cumulated_regions()

bool copy_value_of_write_with_cumulated_regions

(

const char *

module_name

)

PIPS pass.

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 806 of file copy_value_of_write.c.

                                                                         {
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
//  if(use_points_to) {
//    set_pointer_info_kind(with_points_to); //enough?
//  }
  set_proper_rw_effects((statement_effects)
      db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects)
      db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_live_out_regions((statement_effects)
  //set_out_effects((statement_effects)
      db_get_memory_resource(DBR_LIVE_OUT_REGIONS, module_name, true));
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
 
  //-- Make the job -- //
  //No gen_recurse, only want to work on statement on the first level of the function
  copy_write_statement_with_cumulated_regions(module_statement);
//  gen_recurse(module_statement, statement_domain, gen_true, copy_write_statement_with_cumulated_regions);
//  if(use_points_to) {
//    //TODO
//    //gen_recurse(module_statement, statement_domain, gen_true, copy_write_statement_with_cumulated_regions);
//  }
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  // Removed useless block created by the insert_statement
  unspaghettify_statement(module_statement);
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
 
  reset_ordering_to_statement();
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  reset_live_out_regions();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References copy_write_statement_with_cumulated_regions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_live_out_regions(), reset_ordering_to_statement(), reset_parallel_task_mapping(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_live_out_regions(), set_ordering_to_statement(), set_parallel_task_mapping(), set_proper_rw_effects(), statement_consistent_p(), strdup(), and unspaghettify_statement().

Here is the call graph for this function:

copy_variable_declaration_commenter()

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

static

Pass: COPY_VALUE_OF_WRITE Debug mode: MPI_GENERATION_DEBUG_LEVEL Properties used:

• MPI_NBR_CLUSTER
• MPI_DUPLICATE_VARIABLE_PREFIX Resource needed:
• DBR_PROPER_EFFECTS
• DBR_CUMULATED_EFFECTS
• DBR_TASK

Pass: COPY_VALUE_OF_WRITE_WITH_CUMULATED_REGIONS Debug mode: MPI_GENERATION_DEBUG_LEVEL Properties used:

• MPI_NBR_CLUSTER
• MPI_DUPLICATE_VARIABLE_PREFIX Resource needed:
• DBR_PROPER_EFFECTS
• DBR_CUMULATED_EFFECTS
• DBR_LIVE_OUT_REGIONS
• DBR_TASK

Definition at line 84 of file copy_value_of_write.c.

                                                                                    {
  return strdup(COMMENT_COPY_VARIABLE);
}

References COMMENT_COPY_VARIABLE, and strdup().

Referenced by copy_write_statement_with_cumulated_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_write_statement()

static void copy_write_statement ( statement  s )

static

copy_write_statement for the statement s, check if there is/are write effect foreach write effect make a copy statement for the variable written on there equivalent for each cluster.

Parameters

s	statement to check if it's need to make copy

Definition at line 495 of file copy_value_of_write.c.

                                              {
  pips_debug(3, "begin\n");
  if (!declaration_statement_p(s)) {
    list lpeffects = NIL;
    list lweffects = NIL;
    int nbr_copy = get_int_property(MPI_GENERATION_NBR_CLUSTER);
    task t = load_parallel_task_mapping(s);
 
    lpeffects = load_proper_rw_effects_list(s);
    lweffects = effects_write_effects(lpeffects);
 
    if (!ENDP(lweffects)) {
      //There is some write
      if (task_on_cluster(t) == -1) {
        //The statement must be executed by all the clusters
        // copy the same statement
        //    lhs=rhs;   ->    lhs=rhs; lhs_1=rhs; ...
        //TODO
        // print_statement(s);
        copy_n_statement(lweffects, nbr_copy, s);
      }
      else {
        //The statement is executed by 1 cluster
        //for each write effect, we make nbr_copy copy statement of the reference of the write effect
        FOREACH(EFFECT, we, lweffects)
          {
          reference wref = effect_any_reference(we);
          entity went = reference_variable(wref);
          // test if the entity decl is not in the private list of the task, if so no copy
          if (!entity_in_list_p(went, task_private_data(t))) {
            // copy the value of the lhs
            //    lhs=rhs;   ->    lhs=rhs; lhs_1=lhs; ...
            if(!effects_package_entity_p(went)
                && !ENTITY_STDERR_P(went) && !ENTITY_STDIN_P(went) && !ENTITY_STDOUT_P(went))
              //don't want, rand, malloc, printf, scanf...
              copy_n_reference(wref, nbr_copy, s);
          }
          }
      }
    }
  }
  pips_debug(3, "end\n");
}

References copy_n_reference(), copy_n_statement(), declaration_statement_p(), EFFECT, effect_any_reference, effects_package_entity_p(), effects_write_effects(), ENDP, entity_in_list_p(), ENTITY_STDERR_P, ENTITY_STDIN_P, ENTITY_STDOUT_P, FOREACH, get_int_property(), load_parallel_task_mapping(), load_proper_rw_effects_list(), MPI_GENERATION_NBR_CLUSTER, NIL, pips_debug, reference_variable, task_on_cluster, and task_private_data.

Referenced by copy_value_of_write().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_write_statement_with_cumulated_regions()

static void copy_write_statement_with_cumulated_regions ( statement  module_statement )

static

copy_write_statement_with_cumulated_regions foreach first level statement in module_statement generate copies for variables present in out-region if it's an array region, generate variable for indices

Parameters

module_statement

a module statement to work on modification of module_statement by side effect

test if the entity went is not in the private list of the task, don't want rand, malloc, printf, scanf... if so no copy

Definition at line 625 of file copy_value_of_write.c.

                                                                                    {
  ifdebug(2) {
    pips_debug(2, "begin\n");
    pips_debug(2, "statement with : \n");
    print_statement(module_statement);
  }
 
  if (statement_sequence_p(module_statement)) {
    list loutregioneffects = NIL;
    list lweffects = NIL;
    task t = task_undefined;
    int nbr_copy = get_int_property(MPI_GENERATION_NBR_CLUSTER);
    sequence seq = statement_sequence(module_statement);
    list stats = sequence_statements(seq);
 
    FOREACH(STATEMENT, s, stats) {
      loutregioneffects = load_live_out_regions_list(s);
      //loutregioneffects = load_statement_out_regions(s);
      //really need? since we use out_regions, all the list of effect must already be write.
      lweffects = effects_write_effects(loutregioneffects);
      t = load_parallel_task_mapping(s);
 
      if (!ENDP(lweffects)) {
        //There is some write
        if (task_on_cluster(t) == -1) {
          //The statement must be executed by all the clusters
          // copy the same statement
          //    lhs=rhs;   ->    lhs=rhs; lhs_1=rhs; ...
          copy_n_statement(lweffects, nbr_copy, s);
          //TODO boucle for min/max à rajouter pour les tableaux
        }
        else {
          //The statement is executed by 1 cluster
          //for each write effect, we make nbr_copy copy statement of the reference of the write effect
          FOREACH(EFFECT, we, lweffects) {
            reference wref = effect_any_reference(we);
            entity went = reference_variable(wref);
 
            /* test if the entity went is not in the private list of the task,
             * don't want rand, malloc, printf, scanf...
             * if so no copy
             */
            if (!entity_in_list_p(went, task_private_data(t)) &&
                !effects_package_entity_p(went) &&
                !ENTITY_STDERR_P(went) && !ENTITY_STDIN_P(went) && !ENTITY_STDOUT_P(went)
            ) {
              // copy the value of the lhs
              //    lhs=rhs;   ->    lhs=rhs; lhs_1=lhs; ...
 
              ifdebug(2) {
                pips_debug(2, "write effect on variable:\n");
                print_entity_variable(went);
                pips_debug(2, "system of constraints:\n");
                print_region_sc(we);
              }
 
              descriptor desceffect = effect_descriptor(we);
              list indices = reference_indices(wref);
 
              //not a write region but still write effect (eg x=0;)
              if (descriptor_none_p(desceffect) || indices == NIL) {
                copy_n_reference(wref, nbr_copy, s);
              }
              //write region (eg a[i]=i; with 0<i<10)
              else if (descriptor_convex_p(desceffect)) {
                Psysteme sc = descriptor_convex(desceffect);
                statement sequence_statement_for_copy = make_empty_block_statement();
                store_or_update_parallel_task_mapping(sequence_statement_for_copy, t);
                //statement sequence_statement_for_copy = make_block_statement(CONS(STATEMENT, make_plain_continue_statement(), NIL));
 
                Psysteme sc2 = sc_dup(sc);
                Pbase base_index = NULL;
                FOREACH(EXPRESSION, index, indices) {
                  entity indexent = expression_to_entity(index);
                  entity nent = region_entity_variable_to_new_declare_entity(indexent, task_id(t));
 
                  sc2 = sc_variable_rename(sc2, (Variable) indexent, (Variable) nent);
                  base_index = base_add_variable(base_index, (Variable) nent);
                }
                //base_index = base_reversal(base_index);
 
                Psysteme condition = SC_UNDEFINED,
                    enumeration = SC_UNDEFINED;
 
                algorithm_row_echelon(sc2, base_index,
                    &condition, &enumeration);
 
                ifdebug(8) {
                  pips_debug(8, "sc:\n");
                  if (sc2!=NULL){
                    sc_print(sc2, (get_variable_name_t) pips_region_user_name);
                    pips_debug(8, "Nb_eq %d , Nb_ineq %d, dimension %d\n", (sc2)->nb_eq, (sc2)->nb_ineq, (sc2)->dimension);
                  }
                  else
                    pips_debug(8, "sc2==NULL\n");
 
                  pips_debug(8, "condition:\n");
                  if (condition!=NULL){
                    sc_print(condition, (get_variable_name_t) pips_region_user_name);
                    pips_debug(8, "Nb_eq %d , Nb_ineq %d, dimension %d\n", (condition)->nb_eq, (condition)->nb_ineq, (condition)->dimension);
                  }
                  else
                    pips_debug(8, "condition==NULL\n");
 
                  pips_debug(8, "enumeration:\n");
                  if (enumeration!=NULL) {
                    sc_print(enumeration, (get_variable_name_t) pips_region_user_name);
                    pips_debug(8, "Nb_eq %d , Nb_ineq %d, dimension %d\n", (enumeration)->nb_eq, (enumeration)->nb_ineq, (enumeration)->dimension);
                  }
                  else
                    pips_debug(8, "enumeration==NULL\n");
                }
 
                statement stat;
                stat = systeme_to_loop_nest(enumeration, base_to_list(base_index),
                    sequence_statement_for_copy,
                    entity_intrinsic(DIVIDE_OPERATOR_NAME));
                statement_convert_to_statement_with_sequence_of_intruction(stat, true);
 
                //add the declarations if necessary
                push_generated_variable_commenter(copy_variable_declaration_commenter);
                BASE_FOREACH(var, base_index) {
                  entity ne = (entity) var;
 
                  //if entity ne not declare, add the declaration
                  if (!entity_in_list_p(ne, statement_to_direct_declarations(stat))) {
                    add_declaration_statement(stat, ne);
                    //add_declaration_statement_at_beginning(stat, ne);
                    statement_declarations(stat) = CONS(ENTITY, ne, statement_declarations(stat));
                    AddLocalEntityToDeclarationsOnly(ne, get_current_module_entity(), stat);
                    //ram r = storage_ram(entity_storage(ne));
                    //entity m = ram_function(r);
                    //AddEntityToDeclarations(ne, m);
                  }
                }
                pop_generated_variable_commenter();
 
                //fill the body of the loop
                //generate the copy lhs0[i0] = lhs[i0]
                copy_n_reference(wref, nbr_copy, sequence_statement_for_copy);
 
                //add the copy array statements (the loop) to the program
                if (!statement_sequence_p(s)) {
                  statement_convert_to_statement_with_sequence_of_intruction(s, true);
                  //statement_convert_to_statement_with_sequence_of_intruction(s, false);
                  //store_or_update_parallel_task_mapping(STATEMENT(CAR(sequence_statements(instruction_sequence(statement_instruction(s))))), t);
                }
                insert_comments_to_statement(stat, "Copy statements generated with OUT-REGION");
                insert_statement(s, stat, false);
              }
              else if (descriptor_convexunion_p(desceffect)) {
                //TODO
                pips_internal_error("Not done yet...\n");
              }
              else {
                pips_internal_error("This case never occurs\n descriptor = %d\n", descriptor_tag(desceffect));
              }
            }
          }
        }
      }
 
      loutregioneffects = NIL;
      lweffects = NIL;
      t = task_undefined;
    }
  }
  else {
    pips_internal_error("The statement must be the module statement (a sequence of instruction).\n");
  }
 
  ifdebug(2) {
    pips_debug(2, "statement with : \n");
    print_statement(module_statement);
    pips_debug(2, "end\n");
  }
}

References add_declaration_statement(), AddLocalEntityToDeclarationsOnly(), algorithm_row_echelon(), base_add_variable(), BASE_FOREACH, base_to_list(), CONS, copy_n_reference(), copy_n_statement(), copy_variable_declaration_commenter(), descriptor_convex, descriptor_convex_p, descriptor_convexunion_p, descriptor_none_p, descriptor_tag, DIVIDE_OPERATOR_NAME, EFFECT, effect_any_reference, effect_descriptor, effects_package_entity_p(), effects_write_effects(), ENDP, ENTITY, entity_in_list_p(), entity_intrinsic(), ENTITY_STDERR_P, ENTITY_STDIN_P, ENTITY_STDOUT_P, EXPRESSION, expression_to_entity(), FOREACH, get_current_module_entity(), get_int_property(), ifdebug, indices, insert_comments_to_statement(), insert_statement(), load_live_out_regions_list(), load_parallel_task_mapping(), make_empty_block_statement(), module_statement, MPI_GENERATION_NBR_CLUSTER, NIL, pips_debug, pips_internal_error, pips_region_user_name(), pop_generated_variable_commenter(), print_entity_variable(), print_region_sc(), print_statement(), push_generated_variable_commenter(), reference_indices, reference_variable, region_entity_variable_to_new_declare_entity(), sc_dup(), sc_print(), sc_variable_rename(), sequence_statements, STATEMENT, statement_convert_to_statement_with_sequence_of_intruction(), statement_declarations, statement_sequence(), statement_sequence_p(), statement_to_direct_declarations(), store_or_update_parallel_task_mapping(), systeme_to_loop_nest(), task_id, task_on_cluster, task_private_data, and task_undefined.

Referenced by copy_value_of_write_with_cumulated_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

make_statement_copy_i()

static statement make_statement_copy_i ( reference  ref, int  i, int  taskid  )

static

make_statement_copy_i generate a copy_statement with ref, generate a statement: ref_i = ref;

Parameters

ref	reference lhs/rhs
i	cluster number for the lhs of the statement generate

Returns

statement: "ref_i = ref;"

Definition at line 274 of file copy_value_of_write.c.

                                                                          {
  statement scopy = statement_undefined;
 
  entity var = reference_variable(ref);
  reference rhsref = copy_reference(ref);
  gen_context_recurse(rhsref, &taskid, reference_domain, gen_true2, translate_reference_region);
  reference lhsref = reference_undefined;
  entity lhsent = entity_undefined;
  string name = "";
  const char * prefix = get_string_property((const char *) MPI_GENERATION_PREFIX);
 
  // name: name of the entity variable for cluster number i
  name = concatenate(
      entity_module_name(var), MODULE_SEP_STRING,
      local_name_to_scope(entity_local_name(var)),
      prefix, entity_user_name(var), "_", i2a(i),
      NULL);
 
  pips_debug(5, "entity name to find : %s \n", name);
 
  //search the entity on proc i corresponded to the entity var to copy
  if ((lhsent = gen_find_tabulated(name, entity_domain)) != entity_undefined) {
    //lhsref = make_reference(lhsent, index_copy_with_translation_of_region(reference_indices(ref)));
    lhsref = make_reference(lhsent, gen_full_copy_list(reference_indices(ref)));
    gen_context_recurse(lhsref, &taskid, reference_domain, gen_true2, translate_reference_region);
    scopy = make_assign_statement(reference_to_expression(lhsref), reference_to_expression(rhsref));
    statement_comments(scopy) = strdup("distributed send/receive");
    pips_assert("statement scopy is consistent", statement_consistent_p(scopy));
  }
  //TODO this is a workaround for global variable
  else if (true) {
    //TOP-LEVEL
    pips_user_warning("entity_module_name(var)=%s", entity_module_name(var));
    scopy = make_nop_statement();
    //scopy = make_continue_statement(entity_undefined);
  }
  else {
    pips_internal_error("The variable with name %s doesn't exist.\n"
        "  PIPS can't generate the copy for this variable.\n"
        "  Try to launch pass VARIABLE_REPLICATION.\n", name);
  }
  ifdebug(5) {
    pips_debug(5, "copy_statement generated:\n");
    print_statement(scopy);
  }
  return scopy;
}

References concatenate(), copy_reference(), entity_domain, entity_local_name(), entity_module_name(), entity_undefined, entity_user_name(), gen_context_recurse, gen_find_tabulated(), gen_full_copy_list(), gen_true2(), get_string_property(), i2a(), ifdebug, local_name_to_scope(), make_assign_statement(), make_nop_statement, make_reference(), MODULE_SEP_STRING, MPI_GENERATION_PREFIX, pips_assert, pips_debug, pips_internal_error, pips_user_warning, prefix, print_statement(), ref, reference_domain, reference_indices, reference_to_expression(), reference_undefined, reference_variable, statement_comments, statement_consistent_p(), statement_undefined, strdup(), and translate_reference_region().

Referenced by copy_n_reference(), and copy_n_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

region_entity_variable_to_new_declare_entity()

static entity region_entity_variable_to_new_declare_entity ( entity  ent, int  taskid  )

static

translate an entity region in a variable entity if it's need if ent is an entity region return a variable entity else ent is already a variable entity so just return ent

Parameters

ent	possible entity region

Returns

an entity variable

Definition at line 227 of file copy_value_of_write.c.

                                                                                   {
  //TODO It will probably be better the have a mapping especially for the constant
  //string prefix = "__index_region_for_copy";
  string scope = strdup(concatenate("0", BLOCK_SEP_STRING, NULL));
  const char * prefix = get_string_property((const char *) MPI_GENERATION_PREFIX);
  string new_name = strdup(concatenate(scope, prefix, "_index_", entity_local_name(ent), "_", i2a(taskid), "_", NULL));
 
  const char * mod_name = get_current_module_name();
  if (variable_phi_p(ent)) {
    return find_or_create_scalar_entity(new_name, mod_name, is_basic_int);
  }
  if (variable_psi_p(ent)) {
    //really need?
    return find_or_create_scalar_entity(new_name, mod_name, is_basic_int);
  }
  if (variable_beta_p(ent)) {
    //really need?
    return find_or_create_scalar_entity(new_name, mod_name, is_basic_int);
  }
  if (variable_rho_p(ent)) {
    //really need?
    return find_or_create_scalar_entity(new_name, mod_name, is_basic_int);
  }
  free(new_name);
  return ent;
}

References BLOCK_SEP_STRING, concatenate(), entity_local_name(), find_or_create_scalar_entity(), free(), get_current_module_name(), get_string_property(), i2a(), is_basic_int, MPI_GENERATION_PREFIX, prefix, strdup(), variable_beta_p, variable_phi_p, variable_psi_p, and variable_rho_p.

Referenced by copy_write_statement_with_cumulated_regions(), and translate_reference_region().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_convert_to_statement_with_sequence_of_intruction()

static void statement_convert_to_statement_with_sequence_of_intruction ( statement  s, bool  extensions_on_sequence  )

static

Maybe these function can be move in statement.c?

statement_convert_to_statement_with_sequence_of_intruction transform a statement s to a statement of sequence Maybe can be move to statement.C but need to add some tests in that case inspired by generic_insert_statement

Parameters

s	statement to convert into a sequence modify s by side effect
extensions_on_sequence	determine where the extension have to be place if true, the extension is for the sequence statement if false, the extension is for the statement inside the sequence

Definition at line 105 of file copy_value_of_write.c.

                                                                                                                  {
  ifdebug(4) {
    pips_debug(4, "begin\n");
    pips_debug(4, "statement to put into a block : \n");
    print_statement(s);
  }
 
  // s2 will be the statement inside the sequence
  // it herite label, number, ordering, comment, declarations and instructions
  //   it doesn't have extensions or synchronization
  statement s2 = make_statement(
      statement_label(s),
      statement_number(s),
      statement_ordering(s),
      statement_comments(s),
      statement_instruction(s),
      statement_declarations(s),
      statement_decls_text(s),
      extensions_on_sequence?empty_extensions():statement_extensions(s),
      make_synchronization_none()
  );
  pips_assert("statement s2 is consistent", statement_consistent_p(s2));
 
  // no duplication
  // The sequence statement lost label, number, ordering, comment, declarations
  //   But keep extensions and synchronization
  statement_label(s)=entity_empty_label();
  statement_number(s)=STATEMENT_NUMBER_UNDEFINED;
  statement_ordering(s)=STATEMENT_ORDERING_UNDEFINED;
  statement_comments(s)=string_undefined;
  statement_instruction(s)=instruction_undefined;
  statement_declarations(s)=NIL;
  statement_decls_text(s)=NULL;
  if (!extensions_on_sequence)
    statement_extensions(s) = empty_extensions();
  //statement_synchronization(s) = make_synchronization_none();
 
  statement_instruction(s) =  make_instruction_sequence(make_sequence(CONS(STATEMENT, s2, NIL)));
  pips_assert("statement s is consistent", statement_consistent_p(s));
 
  /*
   * other possible version for this function
   * BUT statement s can change/isn't modify all the time by side effect
   *   so we have to return the value of a possible new statement
   *   and sometime not a new statement
   *   so not all the time homogeneous in the computation :(
   * remark: if we use this version also have to modify copy_n_reference to make a return statement
  s = make_block_with_stmt_if_not_already(s);
  if (extensions_on_sequence) {
    extensions_non_recursive_free(statement_extensions(s));
    statement_extensions(s) = statement_extensions(STATEMENT(CAR(sequence_statements(instruction_sequence(statement_instruction(s))))));
    statement_extensions(STATEMENT(CAR(sequence_statements(instruction_sequence(statement_instruction(s)))))) = empty_extensions();
  }
  pips_assert("statement s is consistent", statement_consistent_p(s));
  return s;
  */
 
  ifdebug(4) {
    pips_debug(4, "statement after put into a block : \n");
    print_statement(s);
    pips_debug(4, "end\n");
  }
}

References CONS, empty_extensions(), entity_empty_label(), ifdebug, instruction_undefined, make_instruction_sequence(), make_sequence(), make_statement(), make_synchronization_none(), NIL, pips_assert, pips_debug, print_statement(), STATEMENT, statement_comments, statement_consistent_p(), statement_declarations, statement_decls_text, statement_extensions, statement_instruction, statement_label, statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, STATEMENT_ORDERING_UNDEFINED, and string_undefined.

Referenced by copy_n_reference(), copy_n_statement(), and copy_write_statement_with_cumulated_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_with_side_effect_p()

static bool statement_with_side_effect_p ( statement  s )

static

statement_with_side_effect_p Check if the statement make side effect in a variable a side effect for a statement is defined by doing a read and a write on the same variable for the statement

Maybe can be move to statement.c

Parameters

s	statement to check the presence of modification by side effect

Returns

true if the statement modify a variable by side effect

Definition at line 180 of file copy_value_of_write.c.

                                                       {
  list lceffects = load_cumulated_rw_effects_list(s);
  list lreffects = effects_read_effects(lceffects);
  list lweffects = effects_write_effects(lceffects);
 
  FOREACH(EFFECT, we, lweffects) {
    FOREACH(EFFECT, re, lreffects) {
      if (cells_may_conflict_p(effect_cell(we), effect_cell(re))) {
        return true;
      }
    }
  }
  return false;
}

References cells_may_conflict_p(), EFFECT, effect_cell, effects_read_effects(), effects_write_effects(), FOREACH, and load_cumulated_rw_effects_list().

Referenced by copy_n_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_reference_region()

static void translate_reference_region ( reference  ref, int *  taskid  )

static

call with gen_recurse modify by side effect the variable of the reference to be sure to be a variable entity and not a region entity in some cases

Parameters

ref	reference to treat

Definition at line 260 of file copy_value_of_write.c.

                                                                    {
  entity var = reference_variable(ref);
  reference_variable(ref) = region_entity_variable_to_new_declare_entity(var, *taskid);
}

References ref, reference_variable, and region_entity_variable_to_new_declare_entity().

Referenced by make_statement_copy_i().

Here is the call graph for this function:

Here is the caller graph for this function: