phrase_distributor_communication.c File Reference

#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"

Include dependency graph for phrase_distributor_communication.c:

Go to the source code of this file.

Functions
entity	make_start_ru_module (hash_table ht_params, statement *module_statement, int number_of_deployment_units, entity global_common, list l_commons)
	General computation for PHRASE distribution COMMUNICATION STUFFs. More...
entity	make_wait_ru_module (statement *module_statement, _UNUSED_ int number_of_deployment_units, entity global_common, list l_commons)
	Build and store new module WAIT_RU. More...
static statement	make_communication_statement (entity function, entity module, region reg, entity unit_id, entity param, int number_of_deployment_units, bool is_receiving)
	Make communication statement (SEND or RECEIVE data), for a given fonction and region. More...
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)
	Build and store new module used for communication (SEND or RECEIVE scalar params) Create statement module_statement. More...
string	get_dynamic_variable_name (entity dynamic_variable)
	Return DYN_VAR_PARAM_NAME name for a dynamic variable. More...
string	get_ref_var_param_name (entity reference_param)
	Return REF_VAR_PARAM_NAME name for a dynamic variable. More...
string	get_send_param_module_name (entity function, region reg)
	Return SEND_PARAM module name for function and region. More...
string	get_receive_param_module_name (entity function, region reg)
	Return RECEIVE_PARAM module name for function and region. More...
static list	make_scalar_communication_modules (hash_table ht_communications, int number_of_deployment_units, entity global_common, list l_commons, bool is_receiving)
	Internally used for building communication modules. More...
list	make_send_scalar_params_modules (hash_table ht_in_communications, int number_of_deployment_units, entity global_common, list l_commons)
	Build and return list of modules used for INPUT communications (SEND_PARAMETERS...) More...
list	make_receive_scalar_params_modules (hash_table ht_out_communications, int number_of_deployment_units, entity global_common, list l_commons)
	Build and return list of modules used for OUTPUT communications (RECEIVE_PARAMETERS...) More...
void	compute_region_variables (region reg, list *l_reg_params, list *l_reg_variables)
	Build and return parameters (PHI1,PHI2) and dynamic variables for region reg. More...
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)
	Build statement doing data transfer between internal storage for externalized function and parameters from the caller. More...
entity	create_private_integer_variable_for_new_module (string new_name, const char *new_module_name, entity module)
	Creates an integer variable in specified module. More...
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)
	Internally used for making communication module for non-scalar region and function. More...
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)
	Internally used for making all communication modules for non-scalar IN or OUT regions for a given function. More...
list	make_send_array_params_modules (entity function, list l_regions, entity global_common, entity externalized_fonction_common, int number_of_deployment_units)
	Make all SEND_PARAM communication modules for non-scalar regions for a given function. More...
list	make_receive_array_params_modules (entity function, list l_regions, entity global_common, entity externalized_fonction_common, int number_of_deployment_units)
	Make all RECEIVE_PARAM communication modules for non-scalar regions for a given function. More...

Function Documentation

compute_region_variables()

void compute_region_variables	(	region	reg,
		list *	l_reg_params,
		list *	l_reg_variables
	)

Build and return parameters (PHI1,PHI2) and dynamic variables for region reg.

NOT IMPLEMENTED: suppress unused dynamic variables !!!!

An entity in a system that has an undefined storage is necesseraly a PHI entity, not dynamic !!

Definition at line 626 of file phrase_distributor_communication.c.

{
  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");
}   

References Ssysteme::base, CONS, dynamic_area_p(), ENTITY, entity_global_name(), entity_storage, if(), is_storage_ram, NIL, pips_assert, pips_debug, ram_section, region_system, storage_ram, storage_tag, storage_undefined, Svecteur::succ, Svecteur::var, and VECTEUR_NUL_P.

Referenced by make_array_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

create_private_integer_variable_for_new_module()

entity create_private_integer_variable_for_new_module	(	string	new_name,
		const char *	new_module_name,
		entity	module
	)

Creates an integer variable in specified module.

This entity does not exist, we can safely create it

Add to declarations....

Parameters

new_name	ew_name
new_module_name	ew_module_name
module	odule

Definition at line 775 of file phrase_distributor_communication.c.

{
  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;
    }
}

References add_variable_to_area(), AddEntityToDeclarations(), base, basic_tag, concatenate(), DYNAMIC_AREA_LOCAL_NAME, entity_domain, entity_global_name(), entity_storage, entity_type, entity_undefined, FindEntity(), gen_find_tabulated(), is_basic_int, is_basic_overloaded, is_storage_ram, make_entity, make_ram(), make_storage(), MakeBasic(), MakeTypeVariable(), module, MODULE_SEP_STRING, new_variable, NIL, pips_debug, pips_internal_error, storage_undefined, strdup(), type_variable, value_undefined, and variable_basic.

Referenced by make_array_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dynamic_variable_name()

string get_dynamic_variable_name

(

entity

dynamic_variable

)

Return DYN_VAR_PARAM_NAME name for a dynamic variable.

Parameters

dynamic_variable

ynamic_variable

Definition at line 501 of file phrase_distributor_communication.c.

{
  char *buffer;
  asprintf(&buffer,
          DYN_VAR_PARAM_NAME,
          entity_local_name(dynamic_variable));
  return (buffer);
}

References asprintf, buffer, DYN_VAR_PARAM_NAME, and entity_local_name().

Referenced by make_array_communication_module(), and make_array_communication_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_receive_param_module_name()

string get_receive_param_module_name	(	entity	function,
		region	reg
	)

Return RECEIVE_PARAM module name for function and region.

Definition at line 543 of file phrase_distributor_communication.c.

{
  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);
  }
}

References asprintf, buffer, entity_local_name(), entity_type, get_receive_parameter_module_name(), RECEIVE_ARRAY_PARAM_MODULE_NAME, region_entity, region_scalar_p, and type_variable.

Referenced by make_array_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

get_ref_var_param_name()

string get_ref_var_param_name

(

entity

reference_param

)

Return REF_VAR_PARAM_NAME name for a dynamic variable.

Parameters

reference_param

eference_param

Definition at line 513 of file phrase_distributor_communication.c.

{
  char *buffer;
  asprintf(&buffer,
          REF_VAR_PARAM_NAME,
          entity_local_name(reference_param));
  return (buffer);
}

References asprintf, buffer, entity_local_name(), and REF_VAR_PARAM_NAME.

Referenced by make_array_communication_module(), and make_array_communication_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_send_param_module_name()

string get_send_param_module_name	(	entity	function,
		region	reg
	)

Return SEND_PARAM module name for function and region.

Definition at line 525 of file phrase_distributor_communication.c.

{
  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);
  }
}

References asprintf, buffer, entity_local_name(), entity_type, get_send_parameter_module_name(), region_entity, region_scalar_p, SEND_ARRAY_PARAM_MODULE_NAME, and type_variable.

Referenced by make_array_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

make_array_communication_module()

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  )

static

Internally used for making communication module for non-scalar region and function.

list of entities: phi1, phi2,...

list of dynamic variables....

Declare CONTROL_DATA common to be visible here

Declare common for externalized function to be visible here

Definition at line 821 of file phrase_distributor_communication.c.

{
  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;
}

References COM_MODULE_PARAM2_NAME, COM_MODULE_PARAM4_NAME, compute_region_variables(), create_integer_parameter_for_new_module(), create_parameter_for_new_module(), create_private_integer_variable_for_new_module(), declare_common_variables_in_module(), ENTITY, entity_local_name(), entity_type, fprint_environment(), get_current_module_entity(), get_dynamic_variable_name(), get_receive_param_module_name(), get_ref_var_param_name(), get_send_param_module_name(), ifdebug, make_array_communication_statement(), make_empty_subroutine(), make_language_unknown(), MAP, module_name(), module_statement, pips_debug, print_region, region_entity, reset_current_module_entity(), set_current_module_entity(), store_new_module(), and type_variable.

Referenced by make_array_communication_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

make_array_communication_modules()

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  )

static

Internally used for making all communication modules for non-scalar IN or OUT regions for a given function.

Definition at line 914 of file phrase_distributor_communication.c.

{
  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;
}

References CONS, ENTITY, make_array_communication_module(), MAP, NIL, REGION, and region_scalar_p.

Referenced by make_receive_array_params_modules(), and make_send_array_params_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

make_array_communication_statement()

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  )

static

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

!!! WARNING !!! This divide function has to be redefined here to have a positive remainder ! Use an other custom integer division operation !

Definition at line 672 of file phrase_distributor_communication.c.

{
  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;
}

References ASSIGN_OPERATOR_NAME, CONS, divide, DIVIDE_OPERATOR_NAME, effect_any_reference, ENTITY, entity_global_name(), entity_in_module(), entity_intrinsic(), entity_local_name(), entity_to_expression(), EXPRESSION, gen_copy_seq(), gen_nconc(), get_common_param_name(), get_dynamic_variable_name(), get_ref_var_param_name(), ifdebug, make_binary_call_statement(), make_entity_expression(), MAP, module, NIL, pips_debug, print_region, print_statement(), ref, reference_indices, region_entity, region_system, replace_entity(), and systeme_to_loop_nest().

Referenced by make_array_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

make_communication_statement()

static statement make_communication_statement ( entity  function, entity  module, region  reg, entity  unit_id, entity  param, int  number_of_deployment_units, bool  is_receiving  )

static

Make communication statement (SEND or RECEIVE data), for a given fonction and region.

Definition at line 272 of file phrase_distributor_communication.c.

{
  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());
}

References ASSIGN_OPERATOR_NAME, CONS, entity_empty_label(), entity_in_module(), entity_local_name(), entity_to_expression(), EXPRESSION, get_common_param_name(), ifdebug, make_binary_call_statement(), make_continue_statement(), make_entity_expression(), module, NIL, pips_debug, print_region, region_entity, and region_scalar_p.

Referenced by make_scalar_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

make_receive_array_params_modules()

list make_receive_array_params_modules	(	entity	function,
		list	l_regions,
		entity	global_common,
		entity	externalized_fonction_common,
		int	number_of_deployment_units
	)

Make all RECEIVE_PARAM communication modules for non-scalar regions for a given function.

Parameters

function	unction
l_regions	_regions
global_common	lobal_common
externalized_fonction_common	xternalized_fonction_common
number_of_deployment_units	umber_of_deployment_units

Definition at line 961 of file phrase_distributor_communication.c.

{
  return make_array_communication_modules (function,
                                           l_regions,
                                           global_common,
                                           externalized_fonction_common,
                                           number_of_deployment_units,
                                           true);
}

References make_array_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_receive_scalar_params_modules()

list make_receive_scalar_params_modules	(	hash_table	ht_out_communications,
		int	number_of_deployment_units,
		entity	global_common,
		list	l_commons
	)

Build and return list of modules used for OUTPUT communications (RECEIVE_PARAMETERS...)

Parameters

ht_out_communications	t_out_communications
number_of_deployment_units	umber_of_deployment_units
global_common	lobal_common
l_commons	_commons

Definition at line 609 of file phrase_distributor_communication.c.

{
  return make_scalar_communication_modules (ht_out_communications,
                                            number_of_deployment_units,
                                            global_common,
                                            l_commons,
                                            true);
}

References l_commons, and make_scalar_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_scalar_communication_module()

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  )

static

Build and store new module used for communication (SEND or RECEIVE scalar params) Create statement module_statement.

Declare CONTROL_DATA common to be visible here

Declare commons for all externalized functions to be visible here

f (scalar_region_p(reg)) { }

Definition at line 330 of file phrase_distributor_communication.c.

{
  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;
}

References COM_MODULE_PARAM1_NAME, COM_MODULE_PARAM2_NAME, COM_MODULE_PARAM3_NAME, COM_MODULE_PARAM4_NAME, CONS, create_integer_parameter_for_new_module(), create_parameter_for_new_module(), declare_common_variables_in_module(), empty_comments, empty_extensions(), ENTITY, entity_empty_label(), entity_global_name(), entity_in_module(), entity_intrinsic(), entity_to_expression(), entity_undefined, EQUAL_OPERATOR_NAME, fprint_environment(), gen_nreverse(), get_current_module_entity(), get_function_id_name(), get_in_param_id_name(), get_out_param_id_name(), HASH_MAP, ifdebug, is_instruction_sequence, is_instruction_test, l_commons, make_communication_statement(), make_continue_statement(), make_empty_subroutine(), make_instruction(), make_language_unknown(), make_return_statement(), make_sequence(), make_statement(), make_synchronization_none(), make_test(), MakeBinaryCall(), MAP, module_name(), module_statement, NIL, pips_debug, REGION, region_entity, reset_current_module_entity(), set_current_module_entity(), STATEMENT, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, store_new_module(), and test_condition.

Referenced by make_scalar_communication_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

make_scalar_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  )

static

Internally used for building communication modules.

Definition at line 561 of file phrase_distributor_communication.c.

{
  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;
}

References CONS, ENTITY, get_receive_parameter_module_name(), get_send_parameter_module_name(), HASH_MAP, l_commons, make_scalar_communication_module(), module_name(), module_statement, NIL, and pips_debug.

Referenced by make_receive_scalar_params_modules(), and make_send_scalar_params_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

make_send_array_params_modules()

list make_send_array_params_modules	(	entity	function,
		list	l_regions,
		entity	global_common,
		entity	externalized_fonction_common,
		int	number_of_deployment_units
	)

Make all SEND_PARAM communication modules for non-scalar regions for a given function.

Parameters

function	unction
l_regions	_regions
global_common	lobal_common
externalized_fonction_common	xternalized_fonction_common
number_of_deployment_units	umber_of_deployment_units

Definition at line 943 of file phrase_distributor_communication.c.

{
  return make_array_communication_modules (function,
                                           l_regions,
                                           global_common,
                                           externalized_fonction_common,
                                           number_of_deployment_units,
                                           false);
}

References make_array_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_send_scalar_params_modules()

list make_send_scalar_params_modules	(	hash_table	ht_in_communications,
		int	number_of_deployment_units,
		entity	global_common,
		list	l_commons
	)

Build and return list of modules used for INPUT communications (SEND_PARAMETERS...)

Parameters

ht_in_communications	t_in_communications
number_of_deployment_units	umber_of_deployment_units
global_common	lobal_common
l_commons	_commons

Definition at line 593 of file phrase_distributor_communication.c.

{
  return make_scalar_communication_modules (ht_in_communications,
                                            number_of_deployment_units,
                                            global_common,
                                            l_commons,
                                            false);
}

References l_commons, and make_scalar_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_start_ru_module()

entity make_start_ru_module	(	hash_table	ht_params,
		statement *	module_statement,
		int	number_of_deployment_units,
		entity	global_common,
		list	l_commons
	)

General computation for PHRASE distribution COMMUNICATION STUFFs.

Build and store new module START_RU.

phrase_distributor_communication.c

Build and store new module START_RU. Create statement module_statement

Declare CONTROL_DATA common to be visible here

Declare commons for all externalized functions to be visible here

Compute the parameters of call function

Processing PARAMS regions

Make the CALL statement

Parameters

ht_params	t_params
module_statement	odule_statement
number_of_deployment_units	umber_of_deployment_units
global_common	lobal_common
l_commons	_commons

Definition at line 71 of file phrase_distributor_communication.c.

{
  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;
}

References CONS, create_integer_parameter_for_new_module(), db_get_memory_resource(), declare_common_variables_in_module(), DIMENSION, dimension_lower, effect_any_reference, empty_comments, empty_extensions(), ENTITY, entity_empty_label(), entity_global_name(), entity_in_module(), entity_intrinsic(), entity_local_name(), entity_to_expression(), entity_type, entity_undefined, EQUAL_OPERATOR_NAME, EXPRESSION, fprint_environment(), gen_list_patch(), gen_nreverse(), get_common_param_name(), get_current_module_entity(), get_function_id_name(), HASH_MAP, ifdebug, indices, is_instruction_call, is_instruction_sequence, is_instruction_test, l_commons, local_name_to_top_level_entity(), make_call(), make_continue_statement(), make_empty_subroutine(), make_entity_expression(), make_instruction(), make_language_unknown(), make_return_statement(), make_sequence(), make_statement(), make_synchronization_none(), make_test(), MakeBinaryCall(), MAP, module_statement, new_param(), NIL, pips_debug, ref, reference_variable, REGION, reset_current_module_entity(), set_current_module_entity(), START_RU_MODULE_NAME, START_RU_PARAM1_NAME, START_RU_PARAM2_NAME, STATEMENT, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, store_new_module(), strdup(), test_condition, type_variable, and variable_dimensions.

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_wait_ru_module()

entity make_wait_ru_module	(	statement *	module_statement,
		_UNUSED_ int	number_of_deployment_units,
		entity	global_common,
		list	l_commons
	)

Build and store new module WAIT_RU.

Create statement module_statement

Declare CONTROL_DATA common to be visible here

Declare commons for all externalized functions to be visible here

Definition at line 219 of file phrase_distributor_communication.c.

{
  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;
}

References create_integer_parameter_for_new_module(), declare_common_variables_in_module(), ENTITY, entity_global_name(), fprint_environment(), get_current_module_entity(), ifdebug, l_commons, make_empty_subroutine(), make_language_unknown(), make_return_statement(), MAP, module_statement, pips_debug, reset_current_module_entity(), set_current_module_entity(), store_new_module(), strdup(), WAIT_RU_MODULE_NAME, WAIT_RU_PARAM1_NAME, and WAIT_RU_PARAM2_NAME.

Here is the call graph for this function: