phrase_distributor_control_code.c

Go to the documentation of this file.

/*
 
  $Id: phrase_distributor_control_code.c 23412 2017-08-09 15:07:09Z irigoin $
 
  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
#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 "effects-util.h"
#include "pipsdbm.h"
 
#include "text-util.h"
#include "properties.h"
#include "prettyprint.h"
 
#include "dg.h"
 
typedef dg_arc_label arc_label;
typedef dg_vertex_label vertex_label;
 
#include "graph.h"
 
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
#include "semantics.h"
#include "control.h"
#include "callgraph.h"
 
#include "phrase_tools.h"
 
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
 
#include "transformer.h"
 
#include "phrase_distribution.h"
 
/**
 * Create new variable parameter for a newly created module
 */
entity create_parameter_for_new_module (variable var,
                                        const char* parameter_name,
                                        const char* module_name,
                                        entity module,
                                        int param_nb)
{
  entity new_variable;
  parameter new_parameter;
  list module_declarations;
  list module_parameters;
 
  if ((gen_find_tabulated(concatenate(module_name,
                                      MODULE_SEP_STRING,
                                      parameter_name,
                                      NULL),
                          entity_domain)) == entity_undefined)
    {
      /* This entity does not exist, we can safely create it */
     
      new_variable = make_entity (strdup(concatenate(module_name,
                                                     MODULE_SEP_STRING,
                                                     parameter_name, NULL)),
                                  make_type_variable(copy_variable(var)),
                                  make_storage_formal (make_formal(module, param_nb)),
                                  make_value_unknown());
     
  module_declarations = code_declarations(value_code(entity_initial(module)));
 
  code_declarations(value_code(entity_initial(module)))
    = CONS (ENTITY, new_variable, module_declarations);
 
  new_parameter = make_parameter (entity_type(new_variable),
                                  make_mode_reference(),
                                  make_dummy_identifier(new_variable)/*SG used to be strdup("")*/);
 
  module_parameters = functional_parameters(type_functional(entity_type(module)));
 
  functional_parameters(type_functional(entity_type(module)))
    = CONS(PARAMETER, new_parameter, module_parameters);
 
  return new_variable;
    }
  else
    {
      pips_internal_error("Entity already exist: %s", parameter_name);
      return NULL;
    }
}
 
/**
 * Create new integer variable parameter for a newly created module
 */
entity create_integer_parameter_for_new_module (const char* parameter_name,
                                                const char* module_name,
                                                entity module,
                                                int param_nb)
{
  return create_parameter_for_new_module
    (make_variable(MakeBasic(is_basic_int), NIL, NIL),
     parameter_name,
     module_name,
     module,
     param_nb);
}
 
/**
 * Store (PIPDBM) newly created module module with module_statement
 * as USER_FILE by saving pretty printing
 */
void store_new_module (const char* module_name,
                       entity module,
                       statement module_statement)
{
  string source_file;
  text code;
 
  pips_debug(2, "[BEGIN] store_new_module [%s]\n", module_name);
  ifdebug(2) {
    entity set_entity = get_current_module_entity();
    reset_current_module_entity();
    set_current_module_entity(module);
    pips_debug(2, "Statement for module: ");
    print_statement(module_statement);
    pips_debug(7, "Declarations for module: \n");
    MAP (ENTITY, e, {
      pips_debug(2, "Declared entity %s\n", entity_global_name(e));
    },code_declarations(value_code(entity_initial(module))));
    fprint_environment(stderr, module);
    reset_current_module_entity();
    set_current_module_entity(set_entity);
  }
 
  init_prettyprint(empty_text);
  code = text_module(module, module_statement);
  make_text_resource(module_name,
                     DBR_SOURCE_FILE,
                     ".f",
                     code);
  close_prettyprint();
 
  source_file = db_build_file_resource_name(DBR_SOURCE_FILE, module_name, ".f");
 
  pips_debug(5, "Source file : [%s]\n", source_file);
 
  DB_PUT_NEW_FILE_RESOURCE (DBR_USER_FILE, module_name, source_file);
  DB_PUT_NEW_FILE_RESOURCE (DBR_INITIAL_FILE, module_name, source_file);
 
  init_prettyprint(empty_text);
  make_text_resource(module_name,
                     DBR_INITIAL_FILE,
                     ".f_initial",
                     code);
  close_prettyprint();
 
  pips_debug(2, "[END] store_new_module [%s]\n", module_name);
}
        
/**
 * Creates and declares a new variable for a newly created common
 */
entity create_new_common_variable(string name, entity module, entity common, variable var)
{
  int old_size, variable_size;
 
  string var_global_name = strdup(concatenate(module_local_name(module),MODULE_SEP_STRING,
                                              name,NULL));
  type var_type = make_type(is_type_variable, var);
  storage var_storage = storage_undefined;
  value var_value = make_value_unknown();
  entity e = make_entity(var_global_name,var_type,var_storage,var_value);
  list old_layout = area_layout(type_area(entity_type(common)));
  old_size = area_size(type_area(entity_type(common)));
  variable_size = storage_space_of_variable(e);
  pips_debug(2, "New variable %s created with size %d (old_size was:%d)\n", name, variable_size, old_size);
  entity_storage (e) = make_storage(is_storage_ram,
                                    (make_ram(module,common,old_size,NIL)));
  area_layout(type_area(entity_type(common))) = gen_nconc(old_layout,CONS(ENTITY,e,NIL));
  /* gen_nreverse(CONS(ENTITY,e,old_layout)); */
  area_size(type_area(entity_type(common))) = old_size+variable_size;
  AddEntityToDeclarations( e,module);
  return e;
}
 
/**
 * Creates and declares a new scalar variable for a newly created common
 */
entity create_new_scalar_common_variable(string name, entity module, entity common, basic b)
{
  return create_new_common_variable( name,  module,  common, make_variable(b, NIL,NIL));
}
 
/**
 * Creates and declares a new integer scalar variable for a newly created common
 */
entity create_new_integer_scalar_common_variable(string name, entity module, entity common)
{
  return create_new_scalar_common_variable (name, module, common, MakeBasic(is_basic_int));
}
 
/**
 * Creates all the things that need to be created in order to declare common
 * in module (all the variable are created)
 */
void declare_common_variables_in_module (entity common, entity module)
{
  list new_variables = NIL;
  list primary_variables = NIL;
  bool is_primary_area = true;
  int totalized_offset = -1;
 
  /* Compute the primary variables */
  MAP (ENTITY, v, {
    if (is_primary_area) {
      int offset = ram_offset(storage_ram(entity_storage(v)));
      if (offset > totalized_offset) {
        totalized_offset = offset;
        primary_variables = CONS (ENTITY,v,primary_variables);
      }
      else {
        is_primary_area = false;
      }
    }
  }, area_layout(type_area(entity_type(common))));
 
  primary_variables = gen_nreverse(primary_variables);
 
  ifdebug(4) {
    pips_debug(4, "Current layout for %s\n", entity_global_name(common));    
    MAP(ENTITY, v, {
      pips_debug(4, "[%s] offset %"PRIdPTR"\n", entity_global_name(v),ram_offset(storage_ram(entity_storage(v))));    
   }, area_layout(type_area(entity_type(common))));
    pips_debug(4, "Primary variables for %s\n", entity_global_name(common));    
    MAP(ENTITY, v, {
      pips_debug(4, "[%s] offset %"PRIdPTR" PRIMARY\n", entity_global_name(v),ram_offset(storage_ram(entity_storage(v))));    
   }, primary_variables);
  }
 
  MAP (ENTITY, v, {
 
    /* We iterate on the primary variables declared in the common and
       create a new variable mapping the one declared in common */
 
    entity new_variable; 
    const char* name = entity_local_name(v);
    int v_offset = ram_offset(storage_ram(entity_storage(v)));
   
    /* Creates the name for the new variable */
    string var_global_name = strdup(concatenate(module_local_name(module),
                                                MODULE_SEP_STRING,
                                                name,NULL));
 
    /* Copy type of variable */
    type var_type = copy_type(entity_type(v));
 
    /* Create storage for new variable */
    storage var_storage = make_storage(is_storage_ram,
                                       (make_ram(module,
                                                 common,
                                                 v_offset,
                                                 NIL)));
    /* Copy initial value of variable */
    value var_value = copy_value(entity_initial(v));
 
    pips_debug(7, "Build variable %s\n", var_global_name);
 
    /* Build the new variable */
    new_variable = make_entity(var_global_name,var_type,var_storage,var_value);
 
    /* Mark for addition */
    new_variables = gen_nconc(new_variables,CONS(ENTITY,new_variable,NIL));
 
    pips_debug(7, "Add to declarations %s\n", var_global_name);
 
    /* Add to declarations.... */
    AddEntityToDeclarations( new_variable,module);
   
    pips_debug(7, "New common variable %s declared\n", var_global_name);
   
  }, primary_variables);
 
  /* Add those new variable to common layout */
  {
    list old_layout = area_layout(type_area(entity_type(common)));
    area_layout(type_area(entity_type(common))) = gen_nconc(old_layout,new_variables);
  }
 
  AddEntityToDeclarations( common,module);
  pips_debug(3, "Common %s declared in module %s\n",
             entity_local_name(common),
             entity_local_name(module));
}
 
/*
 * Return CONTROLIZED_STATEMENT_COMMENT
 */
string get_controlized_statement_comment (entity function)
{
  char *buffer;
  asprintf(&buffer,
          CONTROLIZED_STATEMENT_COMMENT,
          entity_local_name(function));
  return (buffer);
}
 
/*
 * Return IN_PARAM_ID_NAME
 */
string get_in_param_id_name (entity variable, entity function)
{
  char *buffer;
  asprintf(&buffer,
          IN_PARAM_ID_NAME,
          entity_local_name(variable),
          entity_local_name(function));
  return (buffer);
}
 
/*
 * Return OUT_PARAM_ID_NAME
 */
string get_out_param_id_name (entity variable, entity function)
{
  char *buffer;
  asprintf(&buffer,
          OUT_PARAM_ID_NAME,
          entity_local_name(variable),
          entity_local_name(function));
  return (buffer);
}
 
/*
 * Return FUNCTION_ID_NAME
 */
string get_function_id_name (entity function)
{
  char *buffer;
  asprintf(&buffer,
          FUNCTION_ID_NAME,
          entity_local_name(function));
  return strdup(buffer);
}
 
/*
 * Return FUNCTION_COMMON_NAME
 */
static string get_function_common_name (entity function)
{
  char *buffer;
  asprintf(&buffer,
          FUNCTION_COMMON_NAME,
          entity_local_name(function));
  return strdup(buffer);
}
 
/*
 * Return COMMON_PARAM_NAME
 */
string get_common_param_name (entity variable, entity function)
{
  char *buffer;
  asprintf(&buffer,
          COMMON_PARAM_NAME,
          entity_local_name(variable),
          entity_local_name(function));
  return strdup(buffer);
}
 
/*
 * Return UNIT_ID_NAME
 */
static string get_unit_id_name (int unit)
{
  char *buffer;
  asprintf(&buffer,UNIT_ID_NAME,unit);
  return strdup(buffer);
}
 
/*
 * Return SEND_PARAMETER_MODULE_NAME
 */
string get_send_parameter_module_name (variable var)
{
  char *buffer;
  asprintf(&buffer,SEND_PARAMETER_MODULE_NAME,variable_to_string(var));
  return strdup(buffer);
}
 
/*
 * Return RECEIVE_PARAMETER_MODULE_NAME
 */
string get_receive_parameter_module_name (variable var)
{
  char *buffer;
  asprintf(&buffer,RECEIVE_PARAMETER_MODULE_NAME,variable_to_string(var));
  return strdup(buffer);
}
 
/**
 * Return entity named name in specified module
 */
entity entity_in_module (const char* name, entity module)
{
  /* Is it the main module ? */
  if (strchr(entity_local_name(module),'%') != NULL) {
    return FindEntity(entity_local_name(module)+1,name);
  }
  else {
    return FindEntity(entity_local_name(module),name);
  }
 
}
 
/**
 * Build and return CONTROL_DATA global common used to store global
 * information on phrase distribution controlization and initialization of
 * values contained in CONTROL_DATA common
 */
static statement
make_global_common_and_initialize (entity main_module,
                                   statement module_stat,
                                   entity *global_common,
                                   int number_of_deployment_units,
                                   hash_table ht_calls,
                                   hash_table ht_in_regions,
                                   hash_table ht_out_regions)
{
  list stats_list = CONS(STATEMENT,module_stat,NIL);
  statement new_stat;
  sequence new_sequence;
  int i;
  list l_in, l_out;
  const char* function_name;
  int id_function, id_param;
  entity units_nb_variable;
  entity functions_nb_variable;
 
  *global_common = make_new_common(CONTROL_DATA_COMMON_NAME,
                                     main_module);
  units_nb_variable = create_new_integer_scalar_common_variable(UNITS_NB_NAME,
                                                                main_module,
                                                                *global_common);
  new_stat = make_assignement_statement
    (units_nb_variable,
     int_to_expression (number_of_deployment_units), NULL);
  stats_list = CONS (STATEMENT, new_stat,stats_list);
 
  if (number_of_deployment_units > 1) {
    for (i=1; i<= number_of_deployment_units; i++) {
      entity unit_id_variable =
        create_new_integer_scalar_common_variable(get_unit_id_name(i),
                                                  main_module,
                                                  *global_common);
      new_stat = make_assignement_statement
        (unit_id_variable,
         int_to_expression (i), NULL);
      stats_list = CONS (STATEMENT, new_stat,stats_list);
    }
  }
 
 
  functions_nb_variable =
    create_new_integer_scalar_common_variable(FUNCTIONS_NB_NAME,
                                              main_module,
                                              *global_common);
 
  new_stat = make_assignement_statement
    (functions_nb_variable,
     int_to_expression (hash_table_entry_count(ht_calls)), NULL);
  stats_list = CONS (STATEMENT, new_stat,stats_list);
 
  id_function = 1;
 
  HASH_MAP (externalized_function, l_calls_for_function, {
   
    entity function = (entity)externalized_function;
    entity function_id_variable;
    function_name = entity_local_name(function);
    pips_debug(2, "Function [%s]\n",function_name);
     
    function_id_variable =
    create_new_integer_scalar_common_variable
    (get_function_id_name(function),
     main_module,
     *global_common);
    new_stat = make_assignement_statement
    (function_id_variable,
     int_to_expression (id_function++), NULL);
    stats_list = CONS (STATEMENT, new_stat,stats_list);
     
    id_param = 1;
   
    l_in = (list)hash_get(ht_in_regions,function);
    l_out = (list)hash_get(ht_out_regions,function);
 
    /*l_in = regions_dup(load_statement_in_regions(s));
      l_out = regions_dup(load_statement_out_regions(s));*/
     
    MAP (REGION, reg, {
      reference ref = effect_any_reference(reg);
      entity variable = reference_variable(ref);
      entity param_id_variable =
        create_new_integer_scalar_common_variable
        (get_in_param_id_name(variable,function),
         main_module,
         *global_common);
      new_stat = make_assignement_statement
        (param_id_variable,
         int_to_expression (id_param++), NULL);
      stats_list = CONS (STATEMENT, new_stat,stats_list);
    }, l_in);
   
    MAP (REGION, reg, {
      reference ref = effect_any_reference(reg);
      entity variable = reference_variable(ref);
      entity param_id_variable =
        create_new_integer_scalar_common_variable
        (get_out_param_id_name(variable,function),
         main_module,
         *global_common);
      new_stat = make_assignement_statement
        (param_id_variable,
         int_to_expression (id_param++), NULL);
      stats_list = CONS (STATEMENT, new_stat,stats_list);
    }, l_out);
   
  }, ht_calls);
 
  new_sequence = make_sequence (stats_list);
 
  return make_statement (entity_empty_label(),
                         STATEMENT_NUMBER_UNDEFINED,
                         STATEMENT_ORDERING_UNDEFINED,
                         empty_comments,
                         make_instruction (is_instruction_sequence,
                                           new_sequence),
                         NIL,NULL,
                         empty_extensions (), make_synchronization_none());
 
}
        
/**
 * Creates and returns a common used to store variable for communications
 * between control code and externalized code
 */
static entity create_externalized_function_common (entity main_module,
                                                   entity externalized_function,
                                                   list params_regions,
                                                   int number_of_deployment_units)
{
  entity returned_common;
 
  returned_common
    = make_new_common(get_function_common_name (externalized_function),
                        main_module);
 
  /* Creates params variables */
  MAP (REGION, reg, {
    entity in_variable = region_entity(reg);
    variable var = copy_variable(type_variable(entity_type(in_variable)));
    /* If many deployment units, add dimension to handle those different units */
    if (number_of_deployment_units > 1) {
      list l_dimensions = variable_dimensions(var);
      variable_dimensions(var)
        = gen_nconc(l_dimensions,
                    CONS(DIMENSION,
                         make_dimension (int_to_expression(1),int_to_expression (number_of_deployment_units), NIL),
                         NIL));
    }
    create_new_common_variable(get_common_param_name(in_variable,externalized_function),
                               main_module,
                               returned_common,
                               var);
  }, params_regions);
 
  return returned_common;
}
 
                           
/**
 * Main function for PHRASE_DISTRIBUTION_CONTROL_CODE
 */
static statement controlize_distribution (statement module_stat,
                                          entity module)
{
  statement returned_statement = module_stat;
  list l_calls;
  const char* function_name;
 
  entity start_ru_module;
  entity wait_ru_module;
  statement start_ru_module_statement;
  statement wait_ru_module_statement;
 
  entity global_common;
  entity externalized_fonction_common;
  list l_commons = NIL;
 
  hash_table ht_calls;
  hash_table ht_params;
  hash_table ht_private;
  hash_table ht_in_regions;
  hash_table ht_out_regions;
   
  hash_table ht_in_communications = hash_table_make(hash_pointer, 0);
  hash_table ht_out_communications = hash_table_make(hash_pointer, 0);
 
  int number_of_deployment_units;
  int unit_id;
 
  /* We identify all the statements containing an externalized-call tag */
  l_calls = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_CALL,
                                                    module_stat);
 
  /* Compute the context of distribution, before to controlize */
  compute_distribution_controlization_context (l_calls,
                                               module_stat,
                                               module,
                                               &ht_calls,
                                               &ht_params,
                                               &ht_private,
                                               &ht_in_regions,
                                               &ht_out_regions);
 
 
  if (hash_table_entry_count (ht_calls)) {
     
    /* OK, be begin deployement... */
   
    string resp;
   
    /* Get the loop label form the user */
    resp = user_request("Deployment on how many externalized units ?\n"
                        "(give its number > 0): ");   
 
    if (sscanf(resp,"%d",&number_of_deployment_units) > 0) {
     
      pips_debug(2, "Deployment on %d units\n", number_of_deployment_units);
     
      /* Declare global common for controlization and make initializations */
      returned_statement
        = make_global_common_and_initialize (module,
                                             module_stat,
                                             &global_common,
                                             number_of_deployment_units,
                                             ht_calls,
                                             ht_in_regions,
                                             ht_out_regions);
     
      /* Let's begin to iterate on all externalized functions,
       * in order to build commons and controlization modules */
     
      pips_debug(2, "Found %d externalized functions\n", hash_table_entry_count(ht_calls));
 
      HASH_MAP (externalized_function, calls_for_f, {
        
        entity f = (entity)externalized_function;
        
        /* Get the function name */
        function_name = entity_local_name(f);
 
        pips_debug(2, "Found %zd calls for externalized function %s\n",
                   gen_length((list)calls_for_f),
                   function_name);
 
        /* Creates a common used to store variable for communications
         * between control code and externalized code */
        externalized_fonction_common =
        create_externalized_function_common (module,
                                             f,
                                             (list)hash_get(ht_params,f),
                                             number_of_deployment_units);
        
        /* And register it to the list of commons */
        l_commons = CONS(ENTITY, externalized_fonction_common, l_commons);
        
        pips_debug(2, "Register input communications\n");
        register_scalar_communications (&ht_in_communications,
                                        f,
                                        (list)hash_get(ht_in_regions,f));
        
        pips_debug(2, "Register output communications\n");
        register_scalar_communications (&ht_out_communications,
                                        f,
                                        (list)hash_get(ht_out_regions,f));
        
        pips_debug(2, "Register and create ARRAY input communications\n");
        make_send_array_params_modules (f,
                                        (list)hash_get(ht_in_regions,f),
                                        global_common,
                                        externalized_fonction_common,
                                        number_of_deployment_units);
 
        pips_debug(2, "Register and create ARRAY output communications\n");
        make_receive_array_params_modules (f,
                                           (list)hash_get(ht_out_regions,f),
                                           global_common,
                                           externalized_fonction_common,
                                           number_of_deployment_units);
        
      }, ht_calls);
     
      /* Build START_RU module */
      start_ru_module = make_start_ru_module (ht_params,
                                              &start_ru_module_statement,
                                              number_of_deployment_units,
                                              global_common,
                                              l_commons);
     
      /* Build WAIT_RU module */
      wait_ru_module = make_wait_ru_module (&wait_ru_module_statement,
                                            number_of_deployment_units,
                                            global_common,
                                            l_commons);
     
#if 0
      /* Build SEND_PARAMS modules */
      list send_params_modules = make_send_scalar_params_modules (ht_in_communications,
                                                             number_of_deployment_units,
                                                             global_common,
                                                             l_commons);
     
      /* Build RECEIVE_PARAMS modules */
      list receive_params_modules = make_receive_scalar_params_modules (ht_out_communications,
                                                                   number_of_deployment_units,
                                                                   global_common,
                                                                   l_commons);
#endif
 
      /* Let's begin to iterate on all externalized functions and statements,
       * in order to add controlization code  */
     
      HASH_MAP (externalized_function, calls_for_f, {
        
        entity f = (entity)externalized_function;
        list l_stats = NIL;
        entity func_id_variable;
        entity unit_id_variable = NULL;
        
        /* Get the function name */
        function_name = entity_local_name(f);
        
        /* Retrieve variables func_id_variable and unit_id_variable */
        func_id_variable = entity_in_module(get_function_id_name(f), module);
 
        /* Iterate on all the statements where externalized function is called */
        
        MAP (STATEMENT, s, {
         
          l_stats = NIL;
          unit_id = 0;
         
          if (number_of_deployment_units > 1) {
            char *question;
            unit_id = 0;
            do {
              asprintf (&question, "Deployment of function %s on which units ?\n(give its number 1-%d):", function_name, number_of_deployment_units);
              resp = user_request(question); 
              sscanf(resp,"%d",&unit_id);          
          free(question);
            }
            while ((unit_id <1) || (unit_id > number_of_deployment_units));
           
            /* Some debug */
            pips_debug(2, "Externalized function [%s] being executed on unit %d:\n", function_name, unit_id);
            ifdebug(2) {
              pips_debug(2, "Current statement is:\n");
              print_statement(s);
            } 
 
            unit_id_variable = entity_in_module (get_unit_id_name(unit_id), module);
 
          }
         
#if 0
          /* Get the called module */
          statement called_module_stat = (statement) db_get_memory_resource(DBR_CODE,
                                                                  function_name,
                                                                  true);
          entity called_module = module_name_to_entity(function_name);
#endif
         
         
          /* SEND PARAMS calls */
          MAP (REGION, reg, {
 
            entity param = entity_in_module(entity_local_name(region_entity(reg)),module);
            entity send_param_module;
            entity param_id_variable;
            statement new_stat;
 
            list call_params = NIL;
 
            send_param_module  = module_name_to_entity(get_send_param_module_name(f, reg));
            pips_debug(7, "Call to [%s]\n", entity_local_name(send_param_module));
            pips_debug(7, "Concerned entity is [%s]\n", entity_local_name(param));
 
            call_params = CONS (EXPRESSION,
                                entity_to_expression(func_id_variable),
                                call_params);
            if (number_of_deployment_units > 1) {
              call_params = CONS (EXPRESSION,
                                  entity_to_expression(unit_id_variable),
                                  call_params);
            }
            param_id_variable = entity_in_module (get_in_param_id_name(param,f),
                                                  module);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param_id_variable),
                                call_params);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param),
                                call_params);
 
           
            if (!region_scalar_p(reg))
              {
                /* Add dynamic variables */
                
                list l_reg_params; /* list of entities: phi1, phi2,... */
                list l_reg_variables; /* list of dynamic variables....*/
                compute_region_variables(reg,&l_reg_params,&l_reg_variables);
                
                MAP (ENTITY, dyn_var, {
                  call_params = CONS (EXPRESSION,
                                      entity_to_expression(dyn_var),
                                      call_params);
                }, l_reg_variables);
              }
 
 
            new_stat = make_statement(entity_empty_label(),
                                      STATEMENT_NUMBER_UNDEFINED,
                                      STATEMENT_ORDERING_UNDEFINED,
                                      empty_comments,
                                      make_instruction(is_instruction_call,
                                                       make_call(send_param_module,
                                                                 gen_nreverse(call_params))),
                                      NIL,NULL,
                                      empty_extensions (), make_synchronization_none());
 
            l_stats = CONS (STATEMENT,
                            new_stat,
                            l_stats);
 
          }, (list)hash_get(ht_in_regions,f));
         
          /* START_RU_CALL */
          {
            list start_ru_call_params = CONS(EXPRESSION,
                                    entity_to_expression(func_id_variable),
                                    (number_of_deployment_units>1)?CONS(EXPRESSION,
                                                                        entity_to_expression(unit_id_variable),
                                                                        NIL):NIL);
            l_stats = CONS (STATEMENT,
                            make_statement(entity_empty_label(),
                                           STATEMENT_NUMBER_UNDEFINED,
                                           STATEMENT_ORDERING_UNDEFINED,
                                           empty_comments,
                                           make_instruction(is_instruction_call,
                                                            make_call(start_ru_module,
                                                                      start_ru_call_params)),
                                           NIL,NULL,
                                           empty_extensions (), make_synchronization_none()),
                            l_stats);
          }
 
          /* WAIT_RU_CALL */
          {
            list wait_ru_call_params = CONS(EXPRESSION,
                                       entity_to_expression(func_id_variable),
                                       (number_of_deployment_units>1)?CONS(EXPRESSION,
                                                                           entity_to_expression(unit_id_variable),
                                                                           NIL):NIL);
            l_stats = CONS (STATEMENT,
                            make_statement(entity_empty_label(),
                                           STATEMENT_NUMBER_UNDEFINED,
                                           STATEMENT_ORDERING_UNDEFINED,
                                           empty_comments,
                                           make_instruction(is_instruction_call,
                                                            make_call(wait_ru_module,
                                                                      wait_ru_call_params)),
                                           NIL,NULL,
                                           empty_extensions (), make_synchronization_none()),
                            l_stats);
          }
         
          /* RECEIVE PARAMS calls */
 
          MAP (REGION, reg, {
 
            entity param = entity_in_module(entity_local_name(region_entity(reg)),module);
            entity receive_param_module;
            entity param_id_variable;
            statement new_stat;
 
            list call_params = NIL;
 
            receive_param_module  = module_name_to_entity(get_receive_param_module_name(f, reg));
            pips_debug(7, "Call to [%s]\n", entity_local_name(receive_param_module));
            pips_debug(7, "Concerned entity is [%s]\n", entity_local_name(param));
 
            call_params = CONS (EXPRESSION,
                                entity_to_expression(func_id_variable),
                                call_params);
            if (number_of_deployment_units > 1) {
              call_params = CONS (EXPRESSION,
                                  entity_to_expression(unit_id_variable),
                                  call_params);
            }
            param_id_variable = entity_in_module (get_out_param_id_name(param,f),
                                                  module);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param_id_variable),
                                call_params);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param),
                                call_params);
 
 
            if (!region_scalar_p(reg))
              {
                /* Add dynamic variables */
                
                list l_reg_params; /* list of entities: phi1, phi2,... */
                list l_reg_variables; /* list of dynamic variables....*/
                compute_region_variables(reg,&l_reg_params,&l_reg_variables);
                
                MAP (ENTITY, dyn_var, {
                  call_params = CONS (EXPRESSION,
                                      entity_to_expression(dyn_var),
                                      call_params);
                }, l_reg_variables);
              }
 
            new_stat = make_statement(entity_empty_label(),
                                      STATEMENT_NUMBER_UNDEFINED,
                                      STATEMENT_ORDERING_UNDEFINED,
                                      empty_comments,
                                      make_instruction(is_instruction_call,
                                                       make_call(receive_param_module,
                                                                 gen_nreverse(call_params))),
                                      NIL,NULL,
                                      empty_extensions (), make_synchronization_none());
 
            l_stats = CONS (STATEMENT,
                            new_stat,
                            l_stats);
 
          }, (list)hash_get(ht_out_regions,f));
         
          /* Now, just inverse list of statements */
 
          l_stats = gen_nreverse(l_stats);
         
          /* And replace CALL instruction by SEQUENCE instruction */
 
          statement_comments(s) = get_controlized_statement_comment(f);
          statement_instruction(s) = make_instruction(is_instruction_sequence,
                                                      make_sequence(l_stats));
 
          ifdebug(7) {
            pips_debug(7, "After controlization, statement is\n");
            print_statement(s);
          }
 
        }, (list)calls_for_f);
        
        pips_debug(2, "Controlization is done on [%s]\n", entity_local_name(f));
        
      }, ht_calls);
     
     
      hash_table_free(ht_calls);
      hash_table_free(ht_params);
      hash_table_free(ht_private);
      hash_table_free(ht_in_regions);
      hash_table_free(ht_out_regions);
 
      HASH_MAP(k,v,{
        hash_table_free(v);     
      },ht_in_communications);
      hash_table_free(ht_in_communications);
 
      HASH_MAP(k,v,{
        hash_table_free(v);     
      },ht_out_communications);
      hash_table_free(ht_out_communications);
 
    }
   
    else {
      pips_debug(2, "Invalid number. Operation aborted\n");
    }
   
  }
  return returned_statement;
}
 
 
/*********************************************************
 * Phase main for PHRASE_DISTRIBUTOR_CONTROL_CODE
 *********************************************************/
 
static entity dynamic_area = entity_undefined;
 
bool phrase_distributor_control_code(const char* module_name)
{
  statement module_stat;
  entity module;
 
  /* set and get the current properties concerning regions */
  set_bool_property("MUST_REGIONS", true);
  set_bool_property("EXACT_REGIONS", true);
  get_regions_properties();
 
  /* get the resources */
  module_stat = (statement) db_get_memory_resource(DBR_CODE,
                                                   module_name,
                                                   true);
 
  module = module_name_to_entity(module_name);
 
  set_current_module_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name)); // FI: redundant
 
  set_cumulated_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_proper_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  module_to_value_mappings(module);
 
  /* sets dynamic_area */
  if (entity_undefined_p(dynamic_area)) {       
    dynamic_area = FindOrCreateEntity(module_local_name(module),
                                      DYNAMIC_AREA_LOCAL_NAME);
  }
 
  debug_on("PHRASE_DISTRIBUTOR_DEBUG_LEVEL");
 
  /* Get the READ, WRITE, IN and OUT regions of the module
   */
  set_rw_effects((statement_effects)
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_in_effects((statement_effects)
                 db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
  set_out_effects((statement_effects)
                  db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
 
  /* Now do the job */
 
  pips_debug(2, "BEGIN of PHRASE_DISTRIBUTOR_CONTROL_CODE\n");
  module_stat = controlize_distribution (module_stat, module);
  pips_debug(2, "END of PHRASE_DISTRIBUTOR_CONTROL_CODE\n");
 
  /* Display the statement before to check consistency */
  ifdebug(4) {
    print_statement(module_stat);
  }
 
  /* Check the coherency of data */
 
  pips_assert("Statement structure is consistent after PHRASE_DISTRIBUTOR_CONTROL_CODE",
              gen_consistent_p((gen_chunk*)module_stat));
             
  pips_assert("Statement is consistent after PHRASE_DISTRIBUTOR_CONTROL_CODE",
               statement_consistent_p(module_stat));
 
 
  /* Reorder the module, because new statements have been added */ 
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
                         compute_callees(module_stat));
 
  /* update/release resources */
  reset_current_module_statement();
  reset_current_module_entity();
  dynamic_area = entity_undefined;
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  free_value_mappings();
 
  debug_off();
 
  return true;
}