phrase_distributor_communication.c

Go to the documentation of this file.

/*
 
  $Id: phrase_distributor_communication.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/**
 * General computation for PHRASE distribution
 * COMMUNICATION STUFFs
 */
 
#include <stdio.h>
#include <ctype.h>
 
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
 
#include "resources.h"
 
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "pipsdbm.h"
 
#include "text-util.h"
 
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
 
#include "phrase_tools.h"
 
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
 
#include "sc.h"
#include "conversion.h"
 
#include "phrase_distribution.h"
 
#include "phrase.h"
/**
 * Build and store new module START_RU.
 * Create statement module_statement
 */
entity make_start_ru_module (hash_table ht_params,
                             statement* module_statement,
                             int number_of_deployment_units,
                             entity global_common,
                             list l_commons)
{
  entity start_ru_module;
  entity func_id;
  entity unit_id = NULL;
  const char* function_name;
  list stat_seq = NIL;
  sequence new_sequence;
  instruction sequence_instruction;
  entity set_entity = get_current_module_entity();
 
  start_ru_module = make_empty_subroutine(START_RU_MODULE_NAME,make_language_unknown());
  pips_debug(2, "Creating module %s\n", entity_global_name(start_ru_module));
  reset_current_module_entity();
  set_current_module_entity(start_ru_module);
  func_id = create_integer_parameter_for_new_module (START_RU_PARAM1_NAME,
                                                     START_RU_MODULE_NAME,
                                                     start_ru_module,
                                                     1);
  if (number_of_deployment_units > 1) {
    unit_id = create_integer_parameter_for_new_module (START_RU_PARAM2_NAME,
                                                       START_RU_MODULE_NAME,
                                                       start_ru_module,
                                                       2);
  }
 
  /* Declare CONTROL_DATA common to be visible here */
  declare_common_variables_in_module (global_common, start_ru_module);
 
  /* Declare commons for all externalized functions to be visible here */
  MAP (ENTITY, com, {
    declare_common_variables_in_module (com, start_ru_module);
  },l_commons);
 
  ifdebug(7) {
    pips_debug(7, "Declarations for START_RU module: \n");
    fprint_environment(stderr, start_ru_module);
  }
 
  HASH_MAP (externalized_function, l_params, {
   
    entity function = (entity)externalized_function;
    expression test_condition;
    test new_test;
    instruction test_instruction;
    statement test_statement;
    statement call_statement;
    list call_params ;
     
    function_name = entity_local_name(function);
#if 0
    statement called_module_stat = (statement) db_get_memory_resource(DBR_CODE,
                                                            function_name,
                                                            true);
   
#endif
    entity called_module = local_name_to_top_level_entity(function_name);
 
    /* Compute the parameters of call function */
    call_params = NIL;
 
    /* Processing PARAMS regions */
    MAP (REGION, reg, {
      expression new_param;
      reference ref = effect_any_reference(reg);
      entity local_variable
        = entity_in_module (get_common_param_name(reference_variable(ref), function), start_ru_module);
      list indices = NIL;
      if (number_of_deployment_units > 1) {
        list primary_indices = variable_dimensions(type_variable(entity_type(local_variable)));
        expression to_be_replaced = NULL;
        MAP (DIMENSION, dim, {
          indices = CONS (EXPRESSION,
                          dimension_lower(dim),
                          indices);
          to_be_replaced=dimension_lower(dim);
        }, primary_indices);
        gen_list_patch (indices,to_be_replaced,entity_to_expression(unit_id));
        indices = gen_nreverse(indices);
      } 
      new_param = make_entity_expression (local_variable, indices);
      call_params = CONS(EXPRESSION, new_param, call_params);
    }, (list)l_params);
 
    call_params = gen_nreverse(call_params);
   
    /* Make the CALL statement */
    call_statement = make_statement(entity_empty_label(),
                                    STATEMENT_NUMBER_UNDEFINED,
                                    STATEMENT_ORDERING_UNDEFINED,
                                    empty_comments,
                                    make_instruction(is_instruction_call,
                                                     make_call(called_module,call_params)),
                                    NIL,NULL,
                                    empty_extensions (), make_synchronization_none());
 
    test_condition
      = MakeBinaryCall (entity_intrinsic(EQUAL_OPERATOR_NAME),
                        entity_to_expression (func_id),
                        entity_to_expression (entity_in_module (get_function_id_name(function), start_ru_module)));
   
    new_test = make_test (test_condition, call_statement,
                          make_continue_statement(entity_undefined));
   
    test_instruction = make_instruction (is_instruction_test,new_test);
 
    test_statement = make_statement (entity_empty_label(),
                                     STATEMENT_NUMBER_UNDEFINED,
                                     STATEMENT_ORDERING_UNDEFINED,
                                     empty_comments,
                                     test_instruction,NIL,NULL,
                                     empty_extensions (), make_synchronization_none());
 
    stat_seq = CONS (STATEMENT, test_statement, stat_seq);
 
  }, ht_params);
 
  stat_seq =  gen_nreverse(CONS(STATEMENT, make_return_statement(start_ru_module), stat_seq));
 
  new_sequence
    = make_sequence (stat_seq);
 
  sequence_instruction
    = make_instruction(is_instruction_sequence,
                       new_sequence);
 
  *module_statement = make_statement(entity_empty_label(),
                                     STATEMENT_NUMBER_UNDEFINED,
                                     STATEMENT_ORDERING_UNDEFINED,
                                     empty_comments,
                                     sequence_instruction,NIL,NULL,
                                     empty_extensions (), make_synchronization_none());
 
  store_new_module (strdup(START_RU_MODULE_NAME), start_ru_module, *module_statement);
 
  reset_current_module_entity();
  set_current_module_entity(set_entity);
  return start_ru_module;
}
 
/**
 * Build and store new module WAIT_RU.
 * Create statement module_statement
 */
entity make_wait_ru_module (statement* module_statement,
          _UNUSED_ int number_of_deployment_units,
                            entity global_common,
                            list l_commons)
{
  entity wait_ru_module;
  entity set_entity = get_current_module_entity();
 
  wait_ru_module = make_empty_subroutine(WAIT_RU_MODULE_NAME,make_language_unknown());
  pips_debug(2, "Creating module %s\n", entity_global_name(wait_ru_module));
  reset_current_module_entity();
  set_current_module_entity(wait_ru_module);
#if 0
  entity func_id = create_integer_parameter_for_new_module (WAIT_RU_PARAM1_NAME,
                                                     WAIT_RU_MODULE_NAME,
                                                     wait_ru_module,
                                                     1);
  entity unit_id = NULL;
  if (number_of_deployment_units > 1) {
    unit_id = create_integer_parameter_for_new_module (WAIT_RU_PARAM2_NAME,
                                                       WAIT_RU_MODULE_NAME,
                                                       wait_ru_module,
                                                       2);
  }
#endif
 
  /* Declare CONTROL_DATA common to be visible here */
  declare_common_variables_in_module (global_common, wait_ru_module);
 
  /* Declare commons for all externalized functions to be visible here */
  MAP (ENTITY, com, {
    declare_common_variables_in_module (com, wait_ru_module);
  },l_commons);
 
  ifdebug(7) {
    pips_debug(7, "Declarations for WAIT_RU module: \n");
    fprint_environment(stderr, wait_ru_module);
  }
 
  *module_statement = make_return_statement(wait_ru_module);
 
  store_new_module (strdup(WAIT_RU_MODULE_NAME), wait_ru_module, *module_statement);
 
  reset_current_module_entity();
  set_current_module_entity(set_entity);
 
  return wait_ru_module;
}
 
/**
 * Make communication statement (SEND or RECEIVE data), for a
 * given fonction and region
 */
static statement make_communication_statement (entity function,
                                               entity module,
                                               region reg,
                                               entity unit_id,
                                               entity param,
                                               int number_of_deployment_units,
                                               bool is_receiving)
{
  entity local_entity = entity_in_module (get_common_param_name (region_entity(reg), function), module);
 
  ifdebug(2) {
    pips_debug(2, "BEGIN make_communication_statement\n");
    pips_debug(2, "Function: [%s]\n",entity_local_name(function));
    pips_debug(2, "Module: [%s]\n",entity_local_name(module));
    pips_debug(2, "Region: \n");
    print_region(reg);
    pips_debug(2, "Local entity: [%s]\n",entity_local_name(local_entity));
  }
 
  if (region_scalar_p(reg)) {
    if (number_of_deployment_units > 1) {
      list inds = CONS(EXPRESSION, entity_to_expression(unit_id),NIL);
      if (is_receiving) {
        return make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                           entity_to_expression(param),
                                           make_entity_expression(local_entity, inds),
                                           NULL);
      }
      else {
        return make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                           make_entity_expression(local_entity, inds),
                                           entity_to_expression(param),
                                           NULL);
      }
    }
    else {
      if (is_receiving) {
        return make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                           entity_to_expression(param),
                                           entity_to_expression(local_entity),
                                           NULL);
      }
      else {
        return make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                           entity_to_expression(local_entity),
                                           entity_to_expression(param),
                                           NULL);
      }
    }
  }
 
  return make_continue_statement(entity_empty_label());
}
 
/**
 * Build and store new module used for communication (SEND or RECEIVE scalar params)
 * Create statement module_statement
 */
static entity make_scalar_communication_module (variable var,
                                                const char* module_name,
                                                hash_table ht_communications,
                                                statement* module_statement,
                                                int number_of_deployment_units,
                                                entity global_common,
                                                list l_commons,
                                                bool is_receiving)
{
  entity new_module;
  entity func_id, param_id, param;
  entity unit_id = NULL;
  entity set_entity = get_current_module_entity();
 
  expression test_condition;
  test new_test;
  instruction test_instruction;
  statement test_statement;
  list stat_seq = NIL;
  statement function_statement;
  sequence new_sequence;
  instruction sequence_instruction;
  int param_nb = 1;
 
  new_module = make_empty_subroutine(module_name,make_language_unknown());
  pips_debug(2, "Creating module %s\n", entity_global_name(new_module));
  reset_current_module_entity();
  set_current_module_entity(new_module);
  func_id = create_integer_parameter_for_new_module (COM_MODULE_PARAM1_NAME,
                                                     module_name,
                                                     new_module,
                                                     param_nb++);
  if (number_of_deployment_units > 1) {
    unit_id = create_integer_parameter_for_new_module (COM_MODULE_PARAM2_NAME,
                                                       module_name,
                                                       new_module,
                                                       param_nb++);
  }
  param_id = create_integer_parameter_for_new_module (COM_MODULE_PARAM3_NAME,
                                                      module_name,
                                                      new_module,
                                                      param_nb++);
 
  param = create_parameter_for_new_module (var,
                                           COM_MODULE_PARAM4_NAME,
                                           module_name,
                                           new_module,
                                           param_nb++);
 
  /* Declare CONTROL_DATA common to be visible here */
  declare_common_variables_in_module (global_common, new_module);
 
  /* Declare commons for all externalized functions to be visible here */
  MAP (ENTITY, com, {
    declare_common_variables_in_module (com, new_module);
  },l_commons);
 
  ifdebug(7) {
    pips_debug(7, "Declarations for %s module: \n", module_name);
    fprint_environment(stderr, new_module);
  }
 
  HASH_MAP (function, l_reg, {
 
    list function_proc_l_stats = NIL;
    expression test_condition2;
    test new_test2;
    instruction test_instruction2;
    statement test_statement2;
    sequence new_sequence2;
    instruction sequence_instruction2;
 
    MAP (REGION, reg, {
     
      statement communication_stat
        = make_communication_statement(function,
                                       new_module,
                                       reg,
                                       unit_id,
                                       param,
                                       number_of_deployment_units,
                                       is_receiving);
     
      entity param_id_value = entity_in_module (is_receiving?get_out_param_id_name(region_entity(reg),function):get_in_param_id_name(region_entity(reg),function), new_module);
     
      test_condition2
      = MakeBinaryCall (entity_intrinsic(EQUAL_OPERATOR_NAME),
                        entity_to_expression (param_id),
                        entity_to_expression (param_id_value));
 
      new_test2 = make_test (test_condition2, communication_stat,
                             make_continue_statement(entity_undefined));
   
      test_instruction2 = make_instruction (is_instruction_test,new_test2);
   
      test_statement2 = make_statement (entity_empty_label(),
                                        STATEMENT_NUMBER_UNDEFINED,
                                        STATEMENT_ORDERING_UNDEFINED,
                                        empty_comments,
                                        test_instruction2,NIL,NULL,
                                        empty_extensions (), make_synchronization_none());
   
      function_proc_l_stats = CONS (STATEMENT, test_statement2, function_proc_l_stats);
 
     /*if (scalar_region_p(reg)) {
        }*/
    },l_reg);
 
    function_proc_l_stats = gen_nreverse(function_proc_l_stats);
 
  new_sequence2
    = make_sequence (function_proc_l_stats);
 
  sequence_instruction2
    = make_instruction(is_instruction_sequence,
                       new_sequence2);
 
  function_statement = make_statement(entity_empty_label(),
                                      STATEMENT_NUMBER_UNDEFINED,
                                      STATEMENT_ORDERING_UNDEFINED,
                                      empty_comments,
                                      sequence_instruction2,NIL,NULL,
                                      empty_extensions (), make_synchronization_none());
 
  test_condition
    = MakeBinaryCall (entity_intrinsic(EQUAL_OPERATOR_NAME),
                      entity_to_expression (func_id),
                      entity_to_expression (entity_in_module (get_function_id_name(function), new_module)));
 
    new_test = make_test (test_condition, function_statement,
                          make_continue_statement(entity_undefined));
   
    test_instruction = make_instruction (is_instruction_test,new_test);
   
    test_statement = make_statement (entity_empty_label(),
                                     STATEMENT_NUMBER_UNDEFINED,
                                     STATEMENT_ORDERING_UNDEFINED,
                                     empty_comments,
                                     test_instruction,NIL,NULL,
                                     empty_extensions (), make_synchronization_none());
   
    stat_seq = CONS (STATEMENT, test_statement, stat_seq);
  }, ht_communications);
 
  stat_seq =  gen_nreverse(CONS(STATEMENT, make_return_statement(new_module), stat_seq));
 
  new_sequence
    = make_sequence (stat_seq);
 
  sequence_instruction
    = make_instruction(is_instruction_sequence,
                       new_sequence);
 
  *module_statement = make_statement(entity_empty_label(),
                                     STATEMENT_NUMBER_UNDEFINED,
                                     STATEMENT_ORDERING_UNDEFINED,
                                     empty_comments,
                                     sequence_instruction,NIL,NULL,
                                     empty_extensions (), make_synchronization_none());
 
  store_new_module (module_name, new_module, *module_statement);
 
  reset_current_module_entity();
  set_current_module_entity(set_entity);
 
  return new_module;
}
 
/**
 * Return DYN_VAR_PARAM_NAME name for a dynamic variable
 */
string get_dynamic_variable_name(entity dynamic_variable)
{
  char *buffer;
  asprintf(&buffer,
          DYN_VAR_PARAM_NAME,
          entity_local_name(dynamic_variable));
  return (buffer);
}
 
/**
 * Return REF_VAR_PARAM_NAME name for a dynamic variable
 */
string get_ref_var_param_name(entity reference_param)
{
  char *buffer;
  asprintf(&buffer,
          REF_VAR_PARAM_NAME,
          entity_local_name(reference_param));
  return (buffer);
}
 
/**
 * Return SEND_PARAM module name for function and region
 */
string get_send_param_module_name(entity function, region reg)
{
  if (region_scalar_p(reg)) {
    return get_send_parameter_module_name(type_variable(entity_type(region_entity(reg))));
  }
  else {
    char *buffer;
    asprintf(&buffer,
            SEND_ARRAY_PARAM_MODULE_NAME,
            entity_local_name(function),
            entity_local_name(region_entity(reg)));
    return (buffer);
  }
}
 
/**
 * Return RECEIVE_PARAM module name for function and region
 */
string get_receive_param_module_name(entity function, region reg)
{
  if (region_scalar_p(reg)) {
    return get_receive_parameter_module_name(type_variable(entity_type(region_entity(reg))));
  }
  else {
    char *buffer;
    asprintf(&buffer,
            RECEIVE_ARRAY_PARAM_MODULE_NAME,
            entity_local_name(function),
            entity_local_name(region_entity(reg)));
    return (buffer);
  }
}
 
/**
 * Internally used for building communication modules
 */
static list make_scalar_communication_modules (hash_table ht_communications,
                                               int number_of_deployment_units,
                                               entity global_common,
                                               list l_commons,
                                               bool is_receiving)
{
  list l_modules = NIL;
 
  HASH_MAP (var, ht_regions_for_functions, {
    const char* module_name = is_receiving?get_receive_parameter_module_name(var):get_send_parameter_module_name (var);
    statement module_statement;
    pips_debug(2, "Creating module [%s]\n", module_name);
    l_modules
      = CONS (ENTITY,
              make_scalar_communication_module (var,
                                                module_name,
                                                ht_regions_for_functions,
                                                &module_statement,
                                                number_of_deployment_units,
                                                global_common,
                                                l_commons,
                                                is_receiving),
              l_modules);
  },ht_communications);
 
  return l_modules;
}
 
/**
 * Build and return list of modules used for INPUT communications
 * (SEND_PARAMETERS...)
 */
list make_send_scalar_params_modules (hash_table ht_in_communications,
                                      int number_of_deployment_units,
                                      entity global_common,
                                      list l_commons)
{
  return make_scalar_communication_modules (ht_in_communications,
                                            number_of_deployment_units,
                                            global_common,
                                            l_commons,
                                            false);
}
 
/**
 * Build and return list of modules used for OUTPUT communications
 * (RECEIVE_PARAMETERS...)
 */
list make_receive_scalar_params_modules (hash_table ht_out_communications,
                                         int number_of_deployment_units,
                                         entity global_common,
                                         list l_commons)
{
  return make_scalar_communication_modules (ht_out_communications,
                                            number_of_deployment_units,
                                            global_common,
                                            l_commons,
                                            true);
}
 
/**
 * Build and return parameters (PHI1,PHI2) and dynamic variables for
 * region reg. 
 * NOT IMPLEMENTED: suppress unused dynamic variables !!!!
 */
void compute_region_variables (region reg,
                               list* l_reg_params,
                               list* l_reg_variables)
{
  Psysteme ps_reg;
  Pbase ps_base;
 
  ps_reg = region_system(reg);
  ps_base = ps_reg->base;
 
  *l_reg_params = NIL;
  *l_reg_variables = NIL;
 
  pips_debug(3, "BEGIN compute_region_variables: \n");
 
  pips_assert("compute_region_variables", ! SC_UNDEFINED_P(ps_reg));
 
  for (; ! VECTEUR_NUL_P(ps_base); ps_base = ps_base->succ) {
 
    entity e = (entity) ps_base->var;
    if (e != NULL) {
      storage s = entity_storage(e);
      pips_debug(7, "Variable: %s\n", entity_global_name(e));
      /* An entity in a system that has an undefined storage is
         necesseraly a PHI entity, not dynamic !! */
      if (s != storage_undefined) {
        if (storage_tag(s) == is_storage_ram) {
          ram r = storage_ram(s);
          if (dynamic_area_p(ram_section(r))) {
            *l_reg_variables = CONS(ENTITY, e, *l_reg_variables);
          }
        }
        else {
          *l_reg_params = CONS(ENTITY, e, *l_reg_params);
        }
      }
    }
  }
  pips_debug(3, "END compute_region_variables: \n");
}   
 
/**
 * Build statement doing data transfer between internal storage for
 * externalized function and parameters from the caller.  This job is done
 * using reg region and systeme_to_loop_nest(...) function
 */
static statement make_array_communication_statement(entity function,
                                                    entity module,
                                                    region reg,
                                                    entity unit_id,
                                                    entity param,
                                                    int number_of_deployment_units,
                                                    bool is_receiving,
                                                    list l_reg_params,
                                                    list l_reg_variables)
{
  Psysteme ps_reg;
  reference ref;
  statement assignement_statement;
  expression local_entity_exp;
  expression param_exp;
  list local_entity_inds;
  list param_inds;
  entity divide;
  statement returned_statement;
 
  entity local_entity = entity_in_module (get_common_param_name (region_entity(reg), function), module);
 
  ifdebug(2) {
    pips_debug(2, "BEGIN make_array_communication_statement\n");
    pips_debug(2, "Function: [%s]\n",entity_local_name(function));
    pips_debug(2, "Module: [%s]\n",entity_local_name(module));
    pips_debug(2, "Region: \n");
    print_region(reg);
    pips_debug(2, "Local entity: [%s]\n",entity_local_name(local_entity));
  }
 
  ps_reg = region_system(reg);
 
  ref = effect_any_reference(reg);
  param_inds = gen_copy_seq(reference_indices(ref));
  if (number_of_deployment_units > 1) {
    local_entity_inds = gen_nconc(gen_copy_seq(reference_indices(ref)),CONS(EXPRESSION, entity_to_expression(unit_id),NIL));
  }
  else {
    local_entity_inds = gen_copy_seq(reference_indices(ref));
  }
  local_entity_exp = make_entity_expression(local_entity, local_entity_inds);
  param_exp = make_entity_expression(param, param_inds);
 
  if (is_receiving) {
    assignement_statement =
      make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                  param_exp,
                                  local_entity_exp,
                                  NULL);
  }
  else {
    assignement_statement =
      make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                  local_entity_exp,
                                  param_exp,
                                  NULL);
  }
 
 
  pips_debug(2, "Loop Nest:\n");
 
  /* !!! WARNING !!!  This divide function has to be redefined here to
   * have a positive remainder ! Use an other custom integer division
   * operation ! */
  divide = entity_intrinsic(DIVIDE_OPERATOR_NAME);
 
  returned_statement = systeme_to_loop_nest(ps_reg,
                                            l_reg_params,
                                            assignement_statement,
                                            divide);
 
 
  MAP (ENTITY, dyn_var, {
    pips_debug(2, "Replace: %s with: %s\n",
               entity_global_name(dyn_var),
               get_dynamic_variable_name(dyn_var));
    replace_entity (returned_statement,dyn_var,
                    entity_in_module(get_dynamic_variable_name(dyn_var), module));
 
  },l_reg_variables);
 
  MAP (ENTITY, phi_param, {
    pips_debug(2, "Replace: %s with: %s\n",
               entity_global_name(phi_param),
               get_ref_var_param_name(phi_param));
    replace_entity (returned_statement,phi_param,
                    entity_in_module(get_ref_var_param_name(phi_param), module));
 
  },l_reg_params);
 
  ifdebug(2) {
    pips_debug(2, "Make this statement:\n");
    print_statement(returned_statement);
    pips_debug(2, "END make_array_communication_statement\n");
  }
 
  return returned_statement;
}
 
/**
 * Creates an integer variable in specified module
 */
entity create_private_integer_variable_for_new_module (string new_name,
                                                       const char* new_module_name,
                                                       entity module)
{
  entity new_variable;
  entity a;
  basic base;
 
  if ((gen_find_tabulated(concatenate(new_module_name,
                                      MODULE_SEP_STRING,
                                      new_name,
                                      NULL),
                          entity_domain)) == entity_undefined)
    {
      /* This entity does not exist, we can safely create it */
     
      new_variable = make_entity (strdup(concatenate(new_module_name,
                                                     MODULE_SEP_STRING,
                                                     new_name, NULL)),
                                  MakeTypeVariable(MakeBasic(is_basic_int), NIL),
                                  storage_undefined,
                                  value_undefined);
      a = FindEntity(new_module_name, DYNAMIC_AREA_LOCAL_NAME);
      base = variable_basic(type_variable(entity_type(new_variable)));
      entity_storage(new_variable) =
        make_storage(is_storage_ram,
                     make_ram(module, a,
                              (basic_tag(base)!=is_basic_overloaded)?
                              (add_variable_to_area(a, new_variable)):(0),
                              NIL));
      /* Add to declarations.... */
      AddEntityToDeclarations( new_variable,module);
      pips_debug(2, "Created new private variable: %s\n", entity_global_name(new_variable));
      return new_variable;
    }
  else
    {
      pips_internal_error("Entity already exist: %s", new_name);
      return NULL;
    }
}
 
/**
 * Internally used for making communication module for non-scalar region
 * and function
 */
static entity make_array_communication_module (entity function,
                                               region reg,
                                               entity global_common,
                                               entity externalized_fonction_common,
                                               int number_of_deployment_units,
                                               bool is_receiving)
{
  entity new_module;
  entity unit_id = NULL;
  entity param;
  const char* module_name = is_receiving?get_receive_param_module_name(function,reg):get_send_param_module_name(function,reg);
  entity set_entity = get_current_module_entity();
  variable var = type_variable(entity_type(region_entity(reg)));
  statement module_statement;
  list l_reg_params; /* list of entities: phi1, phi2,... */
  list l_reg_variables; /* list of dynamic variables....*/
  int param_nb = 1;
 
  new_module = make_empty_subroutine(module_name,make_language_unknown());
  pips_debug(2, "Creating module %s\n", entity_local_name(new_module));
  pips_debug(2, "Function [%s]\n", entity_local_name(function));
  pips_debug(2, "Region: ");
  print_region(reg);
 
 
  compute_region_variables(reg,&l_reg_params,&l_reg_variables);
 
  reset_current_module_entity();
  set_current_module_entity(new_module);
  if (number_of_deployment_units > 1) {
    unit_id = create_integer_parameter_for_new_module (COM_MODULE_PARAM2_NAME,
                                                       module_name,
                                                       new_module,
                                                       param_nb++);
  }
  param = create_parameter_for_new_module (var,
                                           COM_MODULE_PARAM4_NAME,
                                           module_name,
                                           new_module,
                                           param_nb++);
 
  MAP (ENTITY, dyn_var, {
    pips_debug(2, "New parameter: %s\n", get_dynamic_variable_name(dyn_var));
    create_parameter_for_new_module (type_variable(entity_type(dyn_var)),
                                     get_dynamic_variable_name(dyn_var),
                                     module_name,
                                     new_module,
                                     param_nb++);
  },l_reg_variables);
 
  MAP (ENTITY, phi_param, {
    pips_debug(2, "New private variable: %s\n", get_ref_var_param_name(phi_param));
    create_private_integer_variable_for_new_module (get_ref_var_param_name(phi_param),
                                                    module_name,
                                                    new_module);
  },l_reg_params);
 
 
 
  /* Declare CONTROL_DATA common to be visible here */
  declare_common_variables_in_module (global_common, new_module);
 
  /* Declare common for externalized function to be visible here */
  declare_common_variables_in_module (externalized_fonction_common, new_module);
 
  ifdebug(7) {
    pips_debug(7, "Declarations for %s module: \n", module_name);
    fprint_environment(stderr, new_module);
  }
 
  module_statement
    = make_array_communication_statement(function,
                                         new_module,
                                         reg,
                                         unit_id,
                                         param,
                                         number_of_deployment_units,
                                         is_receiving,
                                         l_reg_params,
                                         l_reg_variables);
 
  store_new_module (module_name, new_module, module_statement);
 
  reset_current_module_entity();
  set_current_module_entity(set_entity);
 
  return new_module;
}
 
/**
 * Internally used for making all communication modules for non-scalar IN
 * or OUT regions for a given function
 */
static list make_array_communication_modules (entity function,
                                              list l_regions,
                                              entity global_common,
                                              entity externalized_fonction_common,
                                              int number_of_deployment_units,
                                              bool is_receiving)
{
  list returned = NIL;
 
  MAP (REGION, reg, {
    if (!region_scalar_p(reg)) {
      returned = CONS (ENTITY,
                       make_array_communication_module (function,
                                                        reg,
                                                        global_common,
                                                        externalized_fonction_common,
                                                        number_of_deployment_units,
                                                        is_receiving),
                       returned);
    }
  },l_regions);
 
  return returned;
}
                                           
/**
 * Make all SEND_PARAM communication modules for non-scalar regions for a
 * given function
 */
list make_send_array_params_modules (entity function,
                                     list l_regions,
                                     entity global_common,
                                     entity externalized_fonction_common,
                                     int number_of_deployment_units)
{
  return make_array_communication_modules (function,
                                           l_regions,
                                           global_common,
                                           externalized_fonction_common,
                                           number_of_deployment_units,
                                           false);
}
                                           
/**
 * Make all RECEIVE_PARAM communication modules for non-scalar regions for a
 * given function
 */
list make_receive_array_params_modules (entity function,
                                        list l_regions,
                                        entity global_common,
                                        entity externalized_fonction_common,
                                        int number_of_deployment_units)
{
  return make_array_communication_modules (function,
                                           l_regions,
                                           global_common,
                                           externalized_fonction_common,
                                           number_of_deployment_units,
                                           true);
}