phrase_distribution.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	EXTERNALIZED_CODE_PRAGMA_BEGIN   "BEGIN_FPGA_%s"
#define	EXTERNALIZED_CODE_PRAGMA_END   "END_FPGA_%s"
#define	EXTERNALIZED_CODE_PRAGMA_ANALYZED   "ANALYZED_FPGA_%s (%d statements)"
#define	EXTERNALIZED_CODE_PRAGMA_CALL   "CALL_FPGA_%s"
#define	EXTERNALIZED_FUNCTION_PARAM_NAME   "%s_PARAM_%d"
	Stuff for distribution controlization. More...
#define	EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME   "%s_PRIV"
#define	CONTROL_DATA_COMMON_NAME   "CONTROL_DATA"
#define	FUNCTION_COMMON_NAME   "%s_COMMON"
#define	COMMON_PARAM_NAME   "%s_%s"
#define	DYN_VAR_PARAM_NAME   "%s_DV_PARAM"
#define	REF_VAR_PARAM_NAME   "%s_REF_PARAM"
#define	UNITS_NB_NAME   "UNITS_NB"
#define	UNIT_ID_NAME   "UNIT%d"
#define	FUNCTIONS_NB_NAME   "FUNCTIONS_NB"
#define	FUNCTION_ID_NAME   "%s_FUNCTION"
#define	IN_PARAM_ID_NAME   "%s_%s_IN_PARAM"
#define	OUT_PARAM_ID_NAME   "%s_%s_OUT_PARAM"
#define	CONTROLIZED_STATEMENT_COMMENT   "! CONTROLIZED CALL TO %s\n"
#define	START_RU_MODULE_NAME   "START_RU"
	Stuff for START_RU(...) subroutine generation. More...
#define	START_RU_PARAM1_NAME   "FUNC_ID"
#define	START_RU_PARAM2_NAME   "UNIT_ID"
#define	WAIT_RU_MODULE_NAME   "WAIT_RU"
	Stuff for WAIT_RU(...) subroutine generation. More...
#define	WAIT_RU_PARAM1_NAME   "FUNC_ID"
#define	WAIT_RU_PARAM2_NAME   "UNIT_ID"
#define	VARIABLE_NAME_FORMAT   "_%"PRIdPTR"_%"PRIdPTR
	Stuff for SEND_PARAM.... More...
#define	SEND_PARAMETER_MODULE_NAME   "SEND_%s_PARAMETER"
#define	RECEIVE_PARAMETER_MODULE_NAME   "RECEIVE_%s_PARAMETER"
#define	SEND_ARRAY_PARAM_MODULE_NAME   "SEND_%s_%s_PARAMETER"
#define	RECEIVE_ARRAY_PARAM_MODULE_NAME   "RECEIVE_%s_%s_PARAMETER"
#define	COM_MODULE_PARAM1_NAME   "FUNC_ID"
#define	COM_MODULE_PARAM2_NAME   "UNIT_ID"
#define	COM_MODULE_PARAM3_NAME   "PARAM_ID"
#define	COM_MODULE_PARAM4_NAME   "PARAM"
#define	RU_SEND_FLOAT_PARAM_MODULE_NAME   "RU_SEND_FLOAT_PARAM"
#define	RU_RECEIVE_FLOAT_PARAM_MODULE_NAME   "RU_RECEIVE_FLOAT_PARAM"

Functions
string	get_function_name_by_searching_tag (statement stat, const char *tag)
	Return the identified function name of the externalized portion of code by searching comment matching tag. More...
string	get_externalizable_function_name (statement stat)
	Return the identified function name of the externalized portion of code by searching comment matching tag EXTERNALIZED_CODE_PRAGMA_BEGIN. More...
string	get_externalized_function_name (statement stat)
	Return the identified function name of the externalized portion of code by searching comment matching tag EXTERNALIZED_CODE_PRAGMA_CALL. More...
string	get_externalized_and_analyzed_function_name (statement stat, int *stats_nb)
	Return the identified function name of the externalized portion of code by searching comment matching tags EXTERNALIZED_CODE_PRAGMA_ANALYZED Sets the number of statements of this externalizable statement. More...
bool	compute_distribution_context (list l_stats, statement module_stat, entity module, hash_table *ht_stats, hash_table *ht_params, hash_table *ht_private, hash_table *ht_out_regions, hash_table *ht_in_regions)
	This function is called during PHRASE distribution. More...
bool	compute_distribution_controlization_context (list l_calls, statement module_stat, entity module, hash_table *ht_calls, hash_table *ht_params, hash_table *ht_private, hash_table *ht_out_regions, hash_table *ht_in_regions)
	This function is called during PHRASE distribution controlization. More...
void	register_scalar_communications (hash_table *ht_communications, entity function, list l_regions)
	Build an HASHTABLE where keys are VARIABLE and values are HASHTABLE where keys are modules or externalized function (ENTITY) and values are list of regions. More...
string	variable_to_string (variable var)
	Return a unique (regarding variable_equal_p(var1,var2)) string representation of a variable var. More...
entity	make_start_ru_module (hash_table ht_params, statement *module_statement, int number_of_deployment_units, entity global_common, list l_commons)
	Build and store new module START_RU. More...
entity	make_wait_ru_module (statement *module_statement, int number_of_deployment_units, entity global_common, list l_commons)
	Build and store new module WAIT_RU. 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...
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...
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...
entity	create_private_variable_for_new_module (entity a_variable, const char *new_name, const char *new_module_name, entity module)
	Creates a private variable in specified module. More...
entity	create_parameter_for_new_module (variable var, const char *parameter_name, const char *module_name, entity module, int param_nb)
	Create new variable parameter for a newly created module. More...
entity	create_integer_parameter_for_new_module (const char *parameter_name, const char *module_name, entity module, int param_nb)
	Create new integer variable parameter for a newly created module. More...
void	store_new_module (const char *module_name, entity module, statement module_statement)
	Store (PIPDBM) newly created module module with module_statement as USER_FILE by saving pretty printing. More...
string	get_common_param_name (entity variable, entity function)
string	get_function_id_name (entity function)
string	get_send_parameter_module_name (variable var)
string	get_receive_parameter_module_name (variable var)
string	get_in_param_id_name (entity variable, entity function)
string	get_out_param_id_name (entity variable, entity function)
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...
void	declare_common_variables_in_module (entity common, entity module)
	Creates all the things that need to be created in order to declare common in module (all the variable are created) More...

Macro Definition Documentation

COM_MODULE_PARAM1_NAME

#define COM_MODULE_PARAM1_NAME   "FUNC_ID"

Definition at line 65 of file phrase_distribution.h.

COM_MODULE_PARAM2_NAME

#define COM_MODULE_PARAM2_NAME   "UNIT_ID"

Definition at line 66 of file phrase_distribution.h.

COM_MODULE_PARAM3_NAME

#define COM_MODULE_PARAM3_NAME   "PARAM_ID"

Definition at line 67 of file phrase_distribution.h.

COM_MODULE_PARAM4_NAME

#define COM_MODULE_PARAM4_NAME   "PARAM"

Definition at line 68 of file phrase_distribution.h.

COMMON_PARAM_NAME

#define COMMON_PARAM_NAME   "%s_%s"

Definition at line 37 of file phrase_distribution.h.

CONTROL_DATA_COMMON_NAME

#define CONTROL_DATA_COMMON_NAME   "CONTROL_DATA"

Definition at line 35 of file phrase_distribution.h.

CONTROLIZED_STATEMENT_COMMENT

#define CONTROLIZED_STATEMENT_COMMENT   "! CONTROLIZED CALL TO %s\n"

Definition at line 46 of file phrase_distribution.h.

DYN_VAR_PARAM_NAME

#define DYN_VAR_PARAM_NAME   "%s_DV_PARAM"

Definition at line 38 of file phrase_distribution.h.

EXTERNALIZED_CODE_PRAGMA_ANALYZED

#define EXTERNALIZED_CODE_PRAGMA_ANALYZED   "ANALYZED_FPGA_%s (%d statements)"

Definition at line 29 of file phrase_distribution.h.

EXTERNALIZED_CODE_PRAGMA_BEGIN

#define EXTERNALIZED_CODE_PRAGMA_BEGIN   "BEGIN_FPGA_%s"

Definition at line 27 of file phrase_distribution.h.

EXTERNALIZED_CODE_PRAGMA_CALL

#define EXTERNALIZED_CODE_PRAGMA_CALL   "CALL_FPGA_%s"

Definition at line 30 of file phrase_distribution.h.

EXTERNALIZED_CODE_PRAGMA_END

#define EXTERNALIZED_CODE_PRAGMA_END   "END_FPGA_%s"

Definition at line 28 of file phrase_distribution.h.

EXTERNALIZED_FUNCTION_PARAM_NAME

#define EXTERNALIZED_FUNCTION_PARAM_NAME   "%s_PARAM_%d"

Stuff for distribution controlization.

Definition at line 33 of file phrase_distribution.h.

EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME

#define EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME   "%s_PRIV"

Definition at line 34 of file phrase_distribution.h.

FUNCTION_COMMON_NAME

#define FUNCTION_COMMON_NAME   "%s_COMMON"

Definition at line 36 of file phrase_distribution.h.

FUNCTION_ID_NAME

#define FUNCTION_ID_NAME   "%s_FUNCTION"

Definition at line 43 of file phrase_distribution.h.

FUNCTIONS_NB_NAME

#define FUNCTIONS_NB_NAME   "FUNCTIONS_NB"

Definition at line 42 of file phrase_distribution.h.

IN_PARAM_ID_NAME

#define IN_PARAM_ID_NAME   "%s_%s_IN_PARAM"

Definition at line 44 of file phrase_distribution.h.

OUT_PARAM_ID_NAME

#define OUT_PARAM_ID_NAME   "%s_%s_OUT_PARAM"

Definition at line 45 of file phrase_distribution.h.

RECEIVE_ARRAY_PARAM_MODULE_NAME

#define RECEIVE_ARRAY_PARAM_MODULE_NAME   "RECEIVE_%s_%s_PARAMETER"

Definition at line 64 of file phrase_distribution.h.

RECEIVE_PARAMETER_MODULE_NAME

#define RECEIVE_PARAMETER_MODULE_NAME   "RECEIVE_%s_PARAMETER"

Definition at line 62 of file phrase_distribution.h.

REF_VAR_PARAM_NAME

#define REF_VAR_PARAM_NAME   "%s_REF_PARAM"

Definition at line 39 of file phrase_distribution.h.

RU_RECEIVE_FLOAT_PARAM_MODULE_NAME

#define RU_RECEIVE_FLOAT_PARAM_MODULE_NAME   "RU_RECEIVE_FLOAT_PARAM"

Definition at line 71 of file phrase_distribution.h.

RU_SEND_FLOAT_PARAM_MODULE_NAME

#define RU_SEND_FLOAT_PARAM_MODULE_NAME   "RU_SEND_FLOAT_PARAM"

Definition at line 70 of file phrase_distribution.h.

SEND_ARRAY_PARAM_MODULE_NAME

#define SEND_ARRAY_PARAM_MODULE_NAME   "SEND_%s_%s_PARAMETER"

Definition at line 63 of file phrase_distribution.h.

SEND_PARAMETER_MODULE_NAME

#define SEND_PARAMETER_MODULE_NAME   "SEND_%s_PARAMETER"

Definition at line 61 of file phrase_distribution.h.

START_RU_MODULE_NAME

#define START_RU_MODULE_NAME   "START_RU"

Stuff for START_RU(...) subroutine generation.

Definition at line 49 of file phrase_distribution.h.

START_RU_PARAM1_NAME

#define START_RU_PARAM1_NAME   "FUNC_ID"

Definition at line 50 of file phrase_distribution.h.

START_RU_PARAM2_NAME

#define START_RU_PARAM2_NAME   "UNIT_ID"

Definition at line 51 of file phrase_distribution.h.

UNIT_ID_NAME

#define UNIT_ID_NAME   "UNIT%d"

Definition at line 41 of file phrase_distribution.h.

UNITS_NB_NAME

#define UNITS_NB_NAME   "UNITS_NB"

Definition at line 40 of file phrase_distribution.h.

VARIABLE_NAME_FORMAT

#define VARIABLE_NAME_FORMAT   "_%"PRIdPTR"_%"PRIdPTR

Stuff for SEND_PARAM....

(...) and RECEIVE_PARAM....(...) subroutines generation

Definition at line 60 of file phrase_distribution.h.

WAIT_RU_MODULE_NAME

#define WAIT_RU_MODULE_NAME   "WAIT_RU"

Stuff for WAIT_RU(...) subroutine generation.

Definition at line 54 of file phrase_distribution.h.

WAIT_RU_PARAM1_NAME

#define WAIT_RU_PARAM1_NAME   "FUNC_ID"

Definition at line 55 of file phrase_distribution.h.

WAIT_RU_PARAM2_NAME

#define WAIT_RU_PARAM2_NAME   "UNIT_ID"

Definition at line 56 of file phrase_distribution.h.

Function Documentation

compute_distribution_context()

bool compute_distribution_context	(	list	l_stats,
		statement	module_stat,
		entity	module,
		hash_table *	ht_stats,
		hash_table *	ht_params,
		hash_table *	ht_private,
		hash_table *	ht_in_regions,
		hash_table *	ht_out_regions
	)

This function is called during PHRASE distribution.

distribution_context.c

The goal here is to compute the context of the distribution from a given list of statements (after distribution initialization). Those results are stored in following hashtable:

HT_STATS: This hashtable stores the statement (values) associated to names (keys) of externalized function.

HT_PARAMS: This hashtable stores the list of regions (values) associated to names (keys) of externalized function. Those regions are computed as union of IN and OUT regions of specified statement. If two or more regions refer to the same variable (entity), those regions are transformed into ONE region (which could be converted to a MAY region). This hashtable is used to compute the parameters of specified externalized function.

HT_PRIVATE: This hashtable stores the list of privates regions (values) associated to names (keys) of externalized function. This hashtable is used to compute the private working area in specified externalized function.

HT_IN_REGIONS: This hashtable stores the list of IN regions (values) associated to names (keys) of externalized function. This hashtable is used to compute OUTPUT communication after externalized function execution.

HT_OUT_REGIONS: This hashtable stores the list of OUT regions (values) associated to names (keys) of externalized function. This hashtable is used to compute OUTPUT communication after externalized function execution.

Return true if everything is OK

NB: All lists are sorted using externalized fonction name

lazy init

lazy init

lazy init

lazy init

lazy init

Register new externalized function

Parameters

l_stats	_stats
module_stat	odule_stat
module	odule
ht_stats	t_stats
ht_params	t_params
ht_private	t_private
ht_in_regions	t_in_regions
ht_out_regions	t_out_regions

Definition at line 113 of file distribution_context.c.

{
  bool returned_value = true;
 
  pips_debug(5, "[BEGIN] compute_distribution_context for %s: \n",
             entity_local_name(module));
 
  *ht_stats = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_params = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_private = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_in_regions = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_out_regions = hash_table_make (hash_pointer, 0); /* lazy init */
 
  MAP (STATEMENT, s, {
    statement externalized_code = NULL;
    int stats_nb;
    string function_name = get_externalized_and_analyzed_function_name(s, &stats_nb);
    if (stats_nb > 1) {
      externalized_code = sequence_statement_containing (module_stat, s);
    }
    else if (stats_nb == 1) {
      externalized_code = s;
    }
    else {
      pips_internal_error("Strange externalized code");
    }
 
    /* Register new externalized function */
    pips_debug(5, "Register externalized function %s: \n",
               function_name);
    if (!hash_defined_p(*ht_stats,function_name)) {
      hash_put(*ht_stats,function_name,externalized_code);
    }
    else {
      pips_user_warning("Multiply defined value in STATS hash_table!\n");    
      returned_value = false;
    }
 
    pips_debug(3, "ANALYSING function named [%s]..................\n",
                   function_name);
 
    if (!internal_compute_distribution_context (externalized_code,
                                                ht_params,
                                                ht_private,
                                                ht_in_regions,
                                                ht_out_regions,
                                                function_name)) {
      returned_value = false;
    }
  }, l_stats);
 
  pips_debug(5, "[END] compute_distribution_context for %s: \n",
             entity_local_name(module));
 
  return returned_value;
}

References entity_local_name(), get_externalized_and_analyzed_function_name(), hash_defined_p(), hash_pointer, hash_put(), hash_table_make(), internal_compute_distribution_context(), MAP, module, pips_debug, pips_internal_error, pips_user_warning, sequence_statement_containing(), and STATEMENT.

Referenced by comEngine_distribute(), and distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_distribution_controlization_context()

bool compute_distribution_controlization_context	(	list	l_calls,
		statement	module_stat,
		entity	module,
		hash_table *	ht_calls,
		hash_table *	ht_params,
		hash_table *	ht_private,
		hash_table *	ht_in_regions,
		hash_table *	ht_out_regions
	)

This function is called during PHRASE distribution controlization.

The goal here is to compute the context of the distribution from a given list of call statements (after distribution). Those results are stored in following hashtable:

HT_CALLS: This hashtable stores the list of call statements (values) associated to entity representing the external function (keys). This is a list because a same function can be called from multiple points of original program

HT_PARAMS: This hashtable stores the list of regions (values) associated to entity representing the external function (keys). Those regions are computed as union of IN and OUT regions of specified statement. If two or more regions refer to the same variable (entity), those regions are transformed into ONE region (which could be converted to a MAY region). This hashtable is used to compute the parameters of specified externalized function.

HT_PRIVATE: This hashtable stores the list of privates regions (values) associated to entity representing the external function (keys). This hashtable is used to compute the private working area in specified externalized function.

HT_IN_REGIONS: This hashtable stores the list of IN regions (values) associated to entity representing the external function (keys). This hashtable is used to compute OUTPUT communication after externalized function execution.

HT_OUT_REGIONS: This hashtable stores the list of OUT regions (values) associated to entity representing the external function (keys). This hashtable is used to compute OUTPUT communication after externalized function execution.

Return true if everything is OK

NB: All lists are sorted using externalized fonction name

lazy init

lazy init

lazy init

lazy init

lazy init

Register new externalized function

This function has NOT been already defined, Register it

This function has already been defined, add this statement to the list

Check that IN and OUT regions match !

NOT IMPLEMENTED Yet !

Parameters

l_calls	_calls
module_stat	odule_stat
module	odule
ht_calls	t_calls
ht_params	t_params
ht_private	t_private
ht_in_regions	t_in_regions
ht_out_regions	t_out_regions

Definition at line 216 of file distribution_context.c.

{
  bool returned_value = true;
  string function_name;
  entity externalized_function;
 
  pips_debug(5, "[BEGIN] compute_distribution_controlization_context for %s: \n",
             entity_local_name(module));
  ifdebug(9) {
    print_statement(module_stat);
  }
 
  *ht_calls = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_params = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_private = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_in_regions = hash_table_make (hash_pointer, 0); /* lazy init */
  *ht_out_regions = hash_table_make (hash_pointer, 0); /* lazy init */
 
 
  MAP (STATEMENT, s, {
 
    function_name = get_externalized_function_name(s);
 
    pips_debug(5, "Register statement calling externalized function %s: \n",
               function_name);
 
    externalized_function = module_name_to_entity(function_name);
 
    /* Register new externalized function */
 
    if (!hash_defined_p(*ht_calls,externalized_function)) {
      /* This function has NOT been already defined, 
         Register it */
      pips_debug(2, "Register statement for NEW function %s\n", function_name);
      hash_put(*ht_calls,externalized_function,CONS(STATEMENT, s, NIL));
      if (!internal_compute_distribution_context (s,
                                                  ht_params,
                                                  ht_private,
                                                  ht_in_regions,
                                                  ht_out_regions,
                                                  externalized_function)) {
        returned_value = false;
      }
    }
    else {
      /* This function has already been defined, 
         add this statement to the list */
      list l_stats = (list)hash_get(*ht_calls,externalized_function);
      hash_put(*ht_calls,externalized_function,CONS(STATEMENT, s, l_stats));
      /* Check that IN and OUT regions match ! */
      /* NOT IMPLEMENTED Yet ! */
      pips_debug(2, "Adding statement to function %s\n", function_name);
    }
 
    pips_debug(3, "ANALYSING function named [%s]..................\n",
                   function_name);
 
  }, l_calls);
 
  pips_debug(5, "[END] compute_distribution_controlization_context for %s: \n",
             entity_local_name(module));
 
  return returned_value;
}

References CONS, entity_local_name(), get_externalized_function_name(), hash_defined_p(), hash_get(), hash_pointer, hash_put(), hash_table_make(), ifdebug, internal_compute_distribution_context(), MAP, module, module_name_to_entity(), NIL, pips_debug, print_statement(), and STATEMENT.

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

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 !!!!

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_integer_parameter_for_new_module()

entity create_integer_parameter_for_new_module	(	const char *	parameter_name,
		const char *	module_name,
		entity	module,
		int	param_nb
	)

Create new integer variable parameter for a newly created module.

Parameters

parameter_name	arameter_name
module_name	odule_name
module	odule
param_nb	aram_nb

Definition at line 126 of file phrase_distributor_control_code.c.

{
  return create_parameter_for_new_module
    (make_variable(MakeBasic(is_basic_int), NIL, NIL),
     parameter_name,
     module_name,
     module,
     param_nb);
}

create_parameter_for_new_module()

entity create_parameter_for_new_module	(	variable	var,
		const char *	parameter_name,
		const char *	module_name,
		entity	module,
		int	param_nb
	)

Create new variable parameter for a newly created module.

phrase_distributor_control_code.c

This entity does not exist, we can safely create it

G used to be strdup("")

Parameters

var	ar
parameter_name	arameter_name
module_name	odule_name
module	odule
param_nb	aram_nb

Definition at line 74 of file phrase_distributor_control_code.c.

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

Referenced by create_integer_parameter_for_new_module().

Here is the caller graph for this function:

create_private_variable_for_new_module()

entity create_private_variable_for_new_module	(	entity	a_variable,
		const char *	new_name,
		const char *	new_module_name,
		entity	module
	)

Creates a private variable in specified module.

This entity does not exist, we can safely create it

Parameters

a_variable	_variable
new_name	ew_name
new_module_name	ew_module_name
module	odule

Definition at line 586 of file phrase_distributor.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)),
                                  copy_type (entity_type(a_variable)),
                                  storage_undefined,
                                  copy_value (entity_initial(a_variable)));
      a = FindEntity(new_module_name, DYNAMIC_AREA_LOCAL_NAME); 
      base = variable_basic(type_variable(entity_type(a_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));
      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;
    }
}

Referenced by add_private_variable_to_module().

Here is the caller graph for this function:

declare_common_variables_in_module()

void declare_common_variables_in_module	(	entity	common,
		entity	module
	)

Creates all the things that need to be created in order to declare common in module (all the variable are created)

Compute the primary variables

We iterate on the primary variables declared in the common and create a new variable mapping the one declared in common

Creates the name for the new variable

Copy type of variable

Create storage for new variable

Copy initial value of variable

Build the new variable

Mark for addition

Add to declarations....

Add those new variable to common layout

Parameters

common	ommon
module	odule

Definition at line 237 of file phrase_distributor_control_code.c.

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

get_common_param_name()

string get_common_param_name	(	entity	variable,
		entity	function
	)

Parameters

function

unction

Definition at line 391 of file phrase_distributor_control_code.c.

{
  char *buffer;
  asprintf(&buffer,
          COMMON_PARAM_NAME,
          entity_local_name(variable),
          entity_local_name(function));
  return strdup(buffer);
}

Referenced by create_externalized_function_common().

Here is the caller graph for this function:

get_externalizable_function_name()

string get_externalizable_function_name

(

statement

stat

)

Return the identified function name of the externalized portion of code by searching comment matching tag EXTERNALIZED_CODE_PRAGMA_BEGIN.

Parameters

stat

tat

Definition at line 449 of file distribution_context.c.

{
  return get_function_name_by_searching_tag
    (stat,EXTERNALIZED_CODE_PRAGMA_BEGIN);
}

References EXTERNALIZED_CODE_PRAGMA_BEGIN, and get_function_name_by_searching_tag().

Referenced by identify_statements_to_distribute(), and isolate_code_portion().

Here is the call graph for this function:

Here is the caller graph for this function:

get_externalized_and_analyzed_function_name()

string get_externalized_and_analyzed_function_name	(	statement	stat,
		int *	stats_nb
	)

Return the identified function name of the externalized portion of code by searching comment matching tags EXTERNALIZED_CODE_PRAGMA_ANALYZED Sets the number of statements of this externalizable statement.

Parameters

stat	tat
stats_nb	tats_nb

Definition at line 470 of file distribution_context.c.

{
  string comments;
  string searched_string;
  string comment_portion = strdup(EXTERNALIZED_CODE_PRAGMA_ANALYZED);
  char* function_name = NULL;
  char*  next_line;
  instruction i = statement_instruction(stat);
  
  if (instruction_tag(i) == is_instruction_sequence) {
    stat = STATEMENT(gen_nth(0,sequence_statements(instruction_sequence(i))));
  }
  
  if (!statement_with_empty_comment_p(stat)) {
    searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    comments = strdup(statement_comments(stat));
    next_line = strtok (comments, "\n");
    if (next_line != NULL) {
      do {
        string first_occurence = strstr(next_line,searched_string);
        if (first_occurence != NULL) {
          function_name = malloc(256);
          pips_debug(5, "Scanning: [%s] with [%s]", first_occurence, comment_portion);
          sscanf (first_occurence, comment_portion, function_name, stats_nb);
          pips_debug(5, "Found function: [%s] and %d stats \n", function_name, *stats_nb);
        }
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
  }
 
  return function_name;
}

References EXTERNALIZED_CODE_PRAGMA_ANALYZED, gen_nth(), instruction_sequence, instruction_tag, is_instruction_sequence, malloc(), pips_debug, sequence_statements, STATEMENT, statement_comments, statement_instruction, statement_with_empty_comment_p(), and strdup().

Referenced by compute_distribution_context().

Here is the call graph for this function:

Here is the caller graph for this function:

get_externalized_function_name()

string get_externalized_function_name

(

statement

stat

)

Return the identified function name of the externalized portion of code by searching comment matching tag EXTERNALIZED_CODE_PRAGMA_CALL.

Parameters

stat

tat

Definition at line 459 of file distribution_context.c.

{
  return get_function_name_by_searching_tag
    (stat,EXTERNALIZED_CODE_PRAGMA_CALL);
}

References EXTERNALIZED_CODE_PRAGMA_CALL, and get_function_name_by_searching_tag().

Referenced by compute_distribution_controlization_context().

Here is the call graph for this function:

Here is the caller graph for this function:

get_function_id_name()

string get_function_id_name

(

entity

function

)

Parameters

function

unction

Definition at line 367 of file phrase_distributor_control_code.c.

{
  char *buffer;
  asprintf(&buffer,
          FUNCTION_ID_NAME,
          entity_local_name(function));
  return strdup(buffer);
}

Referenced by controlize_distribution(), and make_global_common_and_initialize().

Here is the caller graph for this function:

get_function_name_by_searching_tag()

string get_function_name_by_searching_tag	(	statement	stat,
		const char *	tag
	)

Return the identified function name of the externalized portion of code by searching comment matching tag.

phrase_distributor.c

Parameters

stat	tat
tag	ag

Definition at line 82 of file phrase_distributor.c.

{
  string comments;
  string searched_string;
  string comment_portion = strdup(tag);
  char* function_name = NULL;
  char*  next_line;
  instruction i = statement_instruction(stat);
 
  ifdebug(5) {
    pips_debug(5, "BEGIN get_function_name_by_searching_tag [%s] on \n", tag);
    print_statement(stat);
  }
 
  if (instruction_tag(i) == is_instruction_sequence) {
    stat = STATEMENT(gen_nth(0,sequence_statements(instruction_sequence(i))));
  }
 
  if (!statement_with_empty_comment_p(stat)) {
    searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    comments = strdup(statement_comments(stat));
    next_line = strtok (comments, "\n");
    if (next_line != NULL) {
      do {
        string first_occurence = strstr(next_line,searched_string);
        if (first_occurence != NULL) {
          function_name = malloc(256);
          sscanf (first_occurence, comment_portion, function_name);
          pips_debug(5, "Found function: [%s]\n", function_name);
        }
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
  }
 
  pips_debug(5, "END get_function_name_by_searching_tag [%s] on \n", tag);
  return function_name;
}

get_in_param_id_name()

string get_in_param_id_name	(	entity	variable,
		entity	function
	)

Parameters

function

unction

Definition at line 341 of file phrase_distributor_control_code.c.

{
  char *buffer;
  asprintf(&buffer,
          IN_PARAM_ID_NAME,
          entity_local_name(variable),
          entity_local_name(function));
  return (buffer);
}

Referenced by controlize_distribution(), and make_global_common_and_initialize().

Here is the caller graph for this function:

get_out_param_id_name()

string get_out_param_id_name	(	entity	variable,
		entity	function
	)

Parameters

function

unction

Definition at line 354 of file phrase_distributor_control_code.c.

{
  char *buffer;
  asprintf(&buffer,
          OUT_PARAM_ID_NAME,
          entity_local_name(variable),
          entity_local_name(function));
  return (buffer);
}

Referenced by controlize_distribution(), and make_global_common_and_initialize().

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_receive_parameter_module_name()

string get_receive_parameter_module_name

(

variable

var

)

Parameters

var

ar

Definition at line 424 of file phrase_distributor_control_code.c.

{
  char *buffer;
  asprintf(&buffer,RECEIVE_PARAMETER_MODULE_NAME,variable_to_string(var));
  return strdup(buffer);
}

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:

get_send_parameter_module_name()

string get_send_parameter_module_name

(

variable

var

)

Parameters

var

ar

Definition at line 414 of file phrase_distributor_control_code.c.

{
  char *buffer;
  asprintf(&buffer,SEND_PARAMETER_MODULE_NAME,variable_to_string(var));
  return strdup(buffer);
}

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

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

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

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

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
	)

Build and store new module START_RU.

Create statement module_statement

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

make_wait_ru_module()

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

Build and store new module WAIT_RU.

Create statement module_statement

register_scalar_communications()

void register_scalar_communications	(	hash_table *	ht_communications,
		entity	function,
		list	l_regions
	)

Build an HASHTABLE where keys are VARIABLE and values are HASHTABLE where keys are modules or externalized function (ENTITY) and values are list of regions.

Iterate on all regions of the given list

Get the variable type

Look if this variable is already registered

Parameters

ht_communications	t_communications
function	unction
l_regions	_regions

Definition at line 538 of file distribution_context.c.

{
 
  /* Iterate on all regions of the given list */
  MAP (REGION, reg, {
 
    if (region_scalar_p(reg)) {
      
      bool already_present = false;
      variable already_registered_variable = NULL;
      
      /* Get the variable type */
      variable var = type_variable(entity_type(region_entity(reg)));
      
      pips_debug(2, "Variable %s %zd \n", basic_to_string(variable_basic(var)), gen_length(variable_dimensions(var)));
      print_region(reg);
      
      /* Look if this variable is already registered */
      HASH_MAP (var2, l2, {
        if (variable_equal_p(var,var2)) {
          already_present = true;
          already_registered_variable = var2;
        }
      },*ht_communications);
      
      if (already_present) {
        hash_table ht_for_variable 
          = (hash_table)hash_get(*ht_communications,
                                 already_registered_variable);
        if (hash_defined_p(ht_for_variable,function)) {
          list old_regs = hash_get(ht_for_variable,
                                   function);
          hash_update(ht_for_variable, function,
                      CONS(REGION,reg,old_regs));
          pips_debug(2, "Add region for existing function\n");
        }
        else {
          hash_put(ht_for_variable, function,
                   CONS(REGION,reg,NIL));
          pips_debug(2, "New region for existing function\n");
        }
      }
      else {
        hash_table new_ht_for_variable
          = hash_table_make(hash_pointer,0);
        hash_put(new_ht_for_variable, function,
                 CONS(REGION,reg,NIL));
        hash_put(*ht_communications,var,new_ht_for_variable);
        pips_debug(2, "New function\n");
      } 
    }
  }, l_regions);
}

References basic_to_string(), CONS, entity_type, gen_length(), hash_defined_p(), hash_get(), HASH_MAP, hash_pointer, hash_put(), hash_table_make(), hash_update(), MAP, NIL, pips_debug, print_region, REGION, region_entity, region_scalar_p, type_variable, variable_basic, variable_dimensions, and variable_equal_p().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

store_new_module()

void store_new_module	(	const char *	module_name,
		entity	module,
		statement	module_statement
	)

Store (PIPDBM) newly created module module with module_statement as USER_FILE by saving pretty printing.

Parameters

module_name	odule_name
module	odule
module_statement	odule_statement

Definition at line 143 of file phrase_distributor_control_code.c.

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

variable_to_string()

string variable_to_string

(

variable

var

)

Return a unique (regarding variable_equal_p(var1,var2)) string representation of a variable var.

Parameters

var

ar

Definition at line 511 of file distribution_context.c.

{
  string returned_value;
  intptr_t low, up;
 
  returned_value = basic_to_string(variable_basic(var));
  (strchr(returned_value,'*'))[0] = '\0';
  FOREACH (DIMENSION, dim, variable_dimensions(var)){
    if ((expression_integer_value(dimension_lower(dim), &low))
        && (expression_integer_value(dimension_upper(dim), &up))) {
      char buffer[256];
      sprintf (buffer, VARIABLE_NAME_FORMAT, low, up);
      returned_value = strdup(concatenate(returned_value,strdup(buffer),NULL));
    }
    else {
      returned_value = strdup(concatenate(returned_value,":UNDEFINED",NULL));
    }
  }
 
  return returned_value;
}

References basic_to_string(), buffer, concatenate(), DIMENSION, dimension_lower, dimension_upper, expression_integer_value(), FOREACH, intptr_t, strdup(), variable_basic, variable_dimensions, and VARIABLE_NAME_FORMAT.

Referenced by get_receive_parameter_module_name(), and get_send_parameter_module_name().

Here is the call graph for this function:

Here is the caller graph for this function: