phrase_distributor_control_code.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 "effects-util.h"
#include "pipsdbm.h"
#include "text-util.h"
#include "properties.h"
#include "prettyprint.h"
#include "dg.h"
#include "graph.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
#include "semantics.h"
#include "control.h"
#include "callgraph.h"
#include "phrase_tools.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "transformer.h"
#include "phrase_distribution.h"

Include dependency graph for phrase_distributor_control_code.c:

Go to the source code of this file.

Typedefs
typedef dg_arc_label	arc_label
typedef dg_vertex_label	vertex_label

Functions
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...
entity	create_new_common_variable (string name, entity module, entity common, variable var)
	Creates and declares a new variable for a newly created common. More...
entity	create_new_scalar_common_variable (string name, entity module, entity common, basic b)
	Creates and declares a new scalar variable for a newly created common. More...
entity	create_new_integer_scalar_common_variable (string name, entity module, entity common)
	Creates and declares a new integer scalar variable for a newly created common. 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...
string	get_controlized_statement_comment (entity function)
string	get_in_param_id_name (entity variable, entity function)
string	get_out_param_id_name (entity variable, entity function)
string	get_function_id_name (entity function)
static string	get_function_common_name (entity function)
string	get_common_param_name (entity variable, entity function)
static string	get_unit_id_name (int unit)
string	get_send_parameter_module_name (variable var)
string	get_receive_parameter_module_name (variable var)
entity	entity_in_module (const char *name, entity module)
	Return entity named name in specified module. More...
static statement	make_global_common_and_initialize (entity main_module, statement module_stat, entity *global_common, int number_of_deployment_units, hash_table ht_calls, hash_table ht_in_regions, hash_table ht_out_regions)
	Build and return CONTROL_DATA global common used to store global information on phrase distribution controlization and initialization of values contained in CONTROL_DATA common. More...
static entity	create_externalized_function_common (entity main_module, entity externalized_function, list params_regions, int number_of_deployment_units)
	Creates and returns a common used to store variable for communications between control code and externalized code. More...
static statement	controlize_distribution (statement module_stat, entity module)
	Main function for PHRASE_DISTRIBUTION_CONTROL_CODE. More...
bool	phrase_distributor_control_code (const char *module_name)

Variables
static entity	dynamic_area = entity_undefined

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Definition at line 48 of file phrase_distributor_control_code.c.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 49 of file phrase_distributor_control_code.c.

Function Documentation

controlize_distribution()

static statement controlize_distribution ( statement  module_stat, entity  module  )

static

Main function for PHRASE_DISTRIBUTION_CONTROL_CODE.

We identify all the statements containing an externalized-call tag

Compute the context of distribution, before to controlize

OK, be begin deployement...

Get the loop label form the user

Declare global common for controlization and make initializations

Let's begin to iterate on all externalized functions, in order to build commons and controlization modules

Get the function name

Creates a common used to store variable for communications between control code and externalized code

And register it to the list of commons

Build START_RU module

Build WAIT_RU module

Let's begin to iterate on all externalized functions and statements, in order to add controlization code

Get the function name

Retrieve variables func_id_variable and unit_id_variable

Iterate on all the statements where externalized function is called

Some debug

SEND PARAMS calls

Add dynamic variables

list of entities: phi1, phi2,...

list of dynamic variables....

START_RU_CALL

WAIT_RU_CALL

RECEIVE PARAMS calls

Add dynamic variables

list of entities: phi1, phi2,...

list of dynamic variables....

Now, just inverse list of statements

And replace CALL instruction by SEQUENCE instruction

Definition at line 615 of file phrase_distributor_control_code.c.

{
  statement returned_statement = module_stat;
  list l_calls;
  const char* function_name;
 
  entity start_ru_module;
  entity wait_ru_module;
  statement start_ru_module_statement;
  statement wait_ru_module_statement;
 
  entity global_common;
  entity externalized_fonction_common;
  list l_commons = NIL;
 
  hash_table ht_calls;
  hash_table ht_params;
  hash_table ht_private;
  hash_table ht_in_regions;
  hash_table ht_out_regions;
   
  hash_table ht_in_communications = hash_table_make(hash_pointer, 0);
  hash_table ht_out_communications = hash_table_make(hash_pointer, 0);
 
  int number_of_deployment_units;
  int unit_id;
 
  /* We identify all the statements containing an externalized-call tag */
  l_calls = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_CALL,
                                                    module_stat);
 
  /* Compute the context of distribution, before to controlize */
  compute_distribution_controlization_context (l_calls,
                                               module_stat,
                                               module,
                                               &ht_calls,
                                               &ht_params,
                                               &ht_private,
                                               &ht_in_regions,
                                               &ht_out_regions);
 
 
  if (hash_table_entry_count (ht_calls)) {
     
    /* OK, be begin deployement... */
   
    string resp;
   
    /* Get the loop label form the user */
    resp = user_request("Deployment on how many externalized units ?\n"
                        "(give its number > 0): ");   
 
    if (sscanf(resp,"%d",&number_of_deployment_units) > 0) {
     
      pips_debug(2, "Deployment on %d units\n", number_of_deployment_units);
     
      /* Declare global common for controlization and make initializations */
      returned_statement
        = make_global_common_and_initialize (module,
                                             module_stat,
                                             &global_common,
                                             number_of_deployment_units,
                                             ht_calls,
                                             ht_in_regions,
                                             ht_out_regions);
     
      /* Let's begin to iterate on all externalized functions,
       * in order to build commons and controlization modules */
     
      pips_debug(2, "Found %d externalized functions\n", hash_table_entry_count(ht_calls));
 
      HASH_MAP (externalized_function, calls_for_f, {
        
        entity f = (entity)externalized_function;
        
        /* Get the function name */
        function_name = entity_local_name(f);
 
        pips_debug(2, "Found %zd calls for externalized function %s\n",
                   gen_length((list)calls_for_f),
                   function_name);
 
        /* Creates a common used to store variable for communications
         * between control code and externalized code */
        externalized_fonction_common =
        create_externalized_function_common (module,
                                             f,
                                             (list)hash_get(ht_params,f),
                                             number_of_deployment_units);
        
        /* And register it to the list of commons */
        l_commons = CONS(ENTITY, externalized_fonction_common, l_commons);
        
        pips_debug(2, "Register input communications\n");
        register_scalar_communications (&ht_in_communications,
                                        f,
                                        (list)hash_get(ht_in_regions,f));
        
        pips_debug(2, "Register output communications\n");
        register_scalar_communications (&ht_out_communications,
                                        f,
                                        (list)hash_get(ht_out_regions,f));
        
        pips_debug(2, "Register and create ARRAY input communications\n");
        make_send_array_params_modules (f,
                                        (list)hash_get(ht_in_regions,f),
                                        global_common,
                                        externalized_fonction_common,
                                        number_of_deployment_units);
 
        pips_debug(2, "Register and create ARRAY output communications\n");
        make_receive_array_params_modules (f,
                                           (list)hash_get(ht_out_regions,f),
                                           global_common,
                                           externalized_fonction_common,
                                           number_of_deployment_units);
        
      }, ht_calls);
     
      /* Build START_RU module */
      start_ru_module = make_start_ru_module (ht_params,
                                              &start_ru_module_statement,
                                              number_of_deployment_units,
                                              global_common,
                                              l_commons);
     
      /* Build WAIT_RU module */
      wait_ru_module = make_wait_ru_module (&wait_ru_module_statement,
                                            number_of_deployment_units,
                                            global_common,
                                            l_commons);
     
#if 0
      /* Build SEND_PARAMS modules */
      list send_params_modules = make_send_scalar_params_modules (ht_in_communications,
                                                             number_of_deployment_units,
                                                             global_common,
                                                             l_commons);
     
      /* Build RECEIVE_PARAMS modules */
      list receive_params_modules = make_receive_scalar_params_modules (ht_out_communications,
                                                                   number_of_deployment_units,
                                                                   global_common,
                                                                   l_commons);
#endif
 
      /* Let's begin to iterate on all externalized functions and statements,
       * in order to add controlization code  */
     
      HASH_MAP (externalized_function, calls_for_f, {
        
        entity f = (entity)externalized_function;
        list l_stats = NIL;
        entity func_id_variable;
        entity unit_id_variable = NULL;
        
        /* Get the function name */
        function_name = entity_local_name(f);
        
        /* Retrieve variables func_id_variable and unit_id_variable */
        func_id_variable = entity_in_module(get_function_id_name(f), module);
 
        /* Iterate on all the statements where externalized function is called */
        
        MAP (STATEMENT, s, {
         
          l_stats = NIL;
          unit_id = 0;
         
          if (number_of_deployment_units > 1) {
            char *question;
            unit_id = 0;
            do {
              asprintf (&question, "Deployment of function %s on which units ?\n(give its number 1-%d):", function_name, number_of_deployment_units);
              resp = user_request(question); 
              sscanf(resp,"%d",&unit_id);          
          free(question);
            }
            while ((unit_id <1) || (unit_id > number_of_deployment_units));
           
            /* Some debug */
            pips_debug(2, "Externalized function [%s] being executed on unit %d:\n", function_name, unit_id);
            ifdebug(2) {
              pips_debug(2, "Current statement is:\n");
              print_statement(s);
            } 
 
            unit_id_variable = entity_in_module (get_unit_id_name(unit_id), module);
 
          }
         
#if 0
          /* Get the called module */
          statement called_module_stat = (statement) db_get_memory_resource(DBR_CODE,
                                                                  function_name,
                                                                  true);
          entity called_module = module_name_to_entity(function_name);
#endif
         
         
          /* SEND PARAMS calls */
          MAP (REGION, reg, {
 
            entity param = entity_in_module(entity_local_name(region_entity(reg)),module);
            entity send_param_module;
            entity param_id_variable;
            statement new_stat;
 
            list call_params = NIL;
 
            send_param_module  = module_name_to_entity(get_send_param_module_name(f, reg));
            pips_debug(7, "Call to [%s]\n", entity_local_name(send_param_module));
            pips_debug(7, "Concerned entity is [%s]\n", entity_local_name(param));
 
            call_params = CONS (EXPRESSION,
                                entity_to_expression(func_id_variable),
                                call_params);
            if (number_of_deployment_units > 1) {
              call_params = CONS (EXPRESSION,
                                  entity_to_expression(unit_id_variable),
                                  call_params);
            }
            param_id_variable = entity_in_module (get_in_param_id_name(param,f),
                                                  module);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param_id_variable),
                                call_params);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param),
                                call_params);
 
           
            if (!region_scalar_p(reg))
              {
                /* Add dynamic variables */
                
                list l_reg_params; /* list of entities: phi1, phi2,... */
                list l_reg_variables; /* list of dynamic variables....*/
                compute_region_variables(reg,&l_reg_params,&l_reg_variables);
                
                MAP (ENTITY, dyn_var, {
                  call_params = CONS (EXPRESSION,
                                      entity_to_expression(dyn_var),
                                      call_params);
                }, l_reg_variables);
              }
 
 
            new_stat = make_statement(entity_empty_label(),
                                      STATEMENT_NUMBER_UNDEFINED,
                                      STATEMENT_ORDERING_UNDEFINED,
                                      empty_comments,
                                      make_instruction(is_instruction_call,
                                                       make_call(send_param_module,
                                                                 gen_nreverse(call_params))),
                                      NIL,NULL,
                                      empty_extensions (), make_synchronization_none());
 
            l_stats = CONS (STATEMENT,
                            new_stat,
                            l_stats);
 
          }, (list)hash_get(ht_in_regions,f));
         
          /* START_RU_CALL */
          {
            list start_ru_call_params = CONS(EXPRESSION,
                                    entity_to_expression(func_id_variable),
                                    (number_of_deployment_units>1)?CONS(EXPRESSION,
                                                                        entity_to_expression(unit_id_variable),
                                                                        NIL):NIL);
            l_stats = CONS (STATEMENT,
                            make_statement(entity_empty_label(),
                                           STATEMENT_NUMBER_UNDEFINED,
                                           STATEMENT_ORDERING_UNDEFINED,
                                           empty_comments,
                                           make_instruction(is_instruction_call,
                                                            make_call(start_ru_module,
                                                                      start_ru_call_params)),
                                           NIL,NULL,
                                           empty_extensions (), make_synchronization_none()),
                            l_stats);
          }
 
          /* WAIT_RU_CALL */
          {
            list wait_ru_call_params = CONS(EXPRESSION,
                                       entity_to_expression(func_id_variable),
                                       (number_of_deployment_units>1)?CONS(EXPRESSION,
                                                                           entity_to_expression(unit_id_variable),
                                                                           NIL):NIL);
            l_stats = CONS (STATEMENT,
                            make_statement(entity_empty_label(),
                                           STATEMENT_NUMBER_UNDEFINED,
                                           STATEMENT_ORDERING_UNDEFINED,
                                           empty_comments,
                                           make_instruction(is_instruction_call,
                                                            make_call(wait_ru_module,
                                                                      wait_ru_call_params)),
                                           NIL,NULL,
                                           empty_extensions (), make_synchronization_none()),
                            l_stats);
          }
         
          /* RECEIVE PARAMS calls */
 
          MAP (REGION, reg, {
 
            entity param = entity_in_module(entity_local_name(region_entity(reg)),module);
            entity receive_param_module;
            entity param_id_variable;
            statement new_stat;
 
            list call_params = NIL;
 
            receive_param_module  = module_name_to_entity(get_receive_param_module_name(f, reg));
            pips_debug(7, "Call to [%s]\n", entity_local_name(receive_param_module));
            pips_debug(7, "Concerned entity is [%s]\n", entity_local_name(param));
 
            call_params = CONS (EXPRESSION,
                                entity_to_expression(func_id_variable),
                                call_params);
            if (number_of_deployment_units > 1) {
              call_params = CONS (EXPRESSION,
                                  entity_to_expression(unit_id_variable),
                                  call_params);
            }
            param_id_variable = entity_in_module (get_out_param_id_name(param,f),
                                                  module);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param_id_variable),
                                call_params);
            call_params = CONS (EXPRESSION,
                                entity_to_expression(param),
                                call_params);
 
 
            if (!region_scalar_p(reg))
              {
                /* Add dynamic variables */
                
                list l_reg_params; /* list of entities: phi1, phi2,... */
                list l_reg_variables; /* list of dynamic variables....*/
                compute_region_variables(reg,&l_reg_params,&l_reg_variables);
                
                MAP (ENTITY, dyn_var, {
                  call_params = CONS (EXPRESSION,
                                      entity_to_expression(dyn_var),
                                      call_params);
                }, l_reg_variables);
              }
 
            new_stat = make_statement(entity_empty_label(),
                                      STATEMENT_NUMBER_UNDEFINED,
                                      STATEMENT_ORDERING_UNDEFINED,
                                      empty_comments,
                                      make_instruction(is_instruction_call,
                                                       make_call(receive_param_module,
                                                                 gen_nreverse(call_params))),
                                      NIL,NULL,
                                      empty_extensions (), make_synchronization_none());
 
            l_stats = CONS (STATEMENT,
                            new_stat,
                            l_stats);
 
          }, (list)hash_get(ht_out_regions,f));
         
          /* Now, just inverse list of statements */
 
          l_stats = gen_nreverse(l_stats);
         
          /* And replace CALL instruction by SEQUENCE instruction */
 
          statement_comments(s) = get_controlized_statement_comment(f);
          statement_instruction(s) = make_instruction(is_instruction_sequence,
                                                      make_sequence(l_stats));
 
          ifdebug(7) {
            pips_debug(7, "After controlization, statement is\n");
            print_statement(s);
          }
 
        }, (list)calls_for_f);
        
        pips_debug(2, "Controlization is done on [%s]\n", entity_local_name(f));
        
      }, ht_calls);
     
     
      hash_table_free(ht_calls);
      hash_table_free(ht_params);
      hash_table_free(ht_private);
      hash_table_free(ht_in_regions);
      hash_table_free(ht_out_regions);
 
      HASH_MAP(k,v,{
        hash_table_free(v);     
      },ht_in_communications);
      hash_table_free(ht_in_communications);
 
      HASH_MAP(k,v,{
        hash_table_free(v);     
      },ht_out_communications);
      hash_table_free(ht_out_communications);
 
    }
   
    else {
      pips_debug(2, "Invalid number. Operation aborted\n");
    }
   
  }
  return returned_statement;
}

References asprintf, compute_distribution_controlization_context(), compute_region_variables(), CONS, create_externalized_function_common(), db_get_memory_resource(), empty_comments, empty_extensions(), ENTITY, entity_empty_label(), entity_in_module(), entity_local_name(), entity_to_expression(), EXPRESSION, EXTERNALIZED_CODE_PRAGMA_CALL, f(), free(), gen_length(), gen_nreverse(), get_controlized_statement_comment(), get_function_id_name(), get_in_param_id_name(), get_out_param_id_name(), get_receive_param_module_name(), get_send_param_module_name(), get_statements_with_comments_containing(), get_unit_id_name(), hash_get(), HASH_MAP, hash_pointer, hash_table_entry_count(), hash_table_free(), hash_table_make(), ifdebug, is_instruction_call, is_instruction_sequence, l_commons, make_call(), make_global_common_and_initialize(), make_instruction(), make_receive_array_params_modules(), make_receive_scalar_params_modules(), make_send_array_params_modules(), make_send_scalar_params_modules(), make_sequence(), make_start_ru_module(), make_statement(), make_synchronization_none(), make_wait_ru_module(), MAP, module, module_name_to_entity(), NIL, pips_debug, print_statement(), REGION, region_entity, region_scalar_p, register_scalar_communications(), STATEMENT, statement_comments, statement_instruction, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, and user_request().

Referenced by phrase_distributor_control_code().

Here is the call graph for this function:

Here is the caller graph for this function:

create_externalized_function_common()

static entity create_externalized_function_common ( entity  main_module, entity  externalized_function, list  params_regions, int  number_of_deployment_units  )

static

Creates and returns a common used to store variable for communications between control code and externalized code.

Creates params variables

If many deployment units, add dimension to handle those different units

Definition at line 578 of file phrase_distributor_control_code.c.

{
  entity returned_common;
 
  returned_common
    = make_new_common(get_function_common_name (externalized_function),
                        main_module);
 
  /* Creates params variables */
  MAP (REGION, reg, {
    entity in_variable = region_entity(reg);
    variable var = copy_variable(type_variable(entity_type(in_variable)));
    /* If many deployment units, add dimension to handle those different units */
    if (number_of_deployment_units > 1) {
      list l_dimensions = variable_dimensions(var);
      variable_dimensions(var)
        = gen_nconc(l_dimensions,
                    CONS(DIMENSION,
                         make_dimension (int_to_expression(1),int_to_expression (number_of_deployment_units), NIL),
                         NIL));
    }
    create_new_common_variable(get_common_param_name(in_variable,externalized_function),
                               main_module,
                               returned_common,
                               var);
  }, params_regions);
 
  return returned_common;
}

References CONS, copy_variable(), create_new_common_variable(), DIMENSION, entity_type, gen_nconc(), get_common_param_name(), get_function_common_name(), int_to_expression(), make_dimension(), make_new_common(), MAP, NIL, REGION, region_entity, 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:

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

References create_parameter_for_new_module(), is_basic_int, make_variable(), MakeBasic(), module, module_name(), and NIL.

Referenced by make_array_communication_module(), make_scalar_communication_module(), make_start_ru_module(), and make_wait_ru_module().

Here is the call graph for this function:

Here is the caller graph for this function:

create_new_common_variable()

entity create_new_common_variable	(	string	name,
		entity	module,
		entity	common,
		variable	var
	)

Creates and declares a new variable for a newly created common.

gen_nreverse(CONS(ENTITY,e,old_layout));

Parameters

name	ame
module	odule
common	ommon
var	ar

Definition at line 194 of file phrase_distributor_control_code.c.

{
  int old_size, variable_size;
 
  string var_global_name = strdup(concatenate(module_local_name(module),MODULE_SEP_STRING,
                                              name,NULL));
  type var_type = make_type(is_type_variable, var);
  storage var_storage = storage_undefined;
  value var_value = make_value_unknown();
  entity e = make_entity(var_global_name,var_type,var_storage,var_value);
  list old_layout = area_layout(type_area(entity_type(common)));
  old_size = area_size(type_area(entity_type(common)));
  variable_size = storage_space_of_variable(e);
  pips_debug(2, "New variable %s created with size %d (old_size was:%d)\n", name, variable_size, old_size);
  entity_storage (e) = make_storage(is_storage_ram,
                                    (make_ram(module,common,old_size,NIL)));
  area_layout(type_area(entity_type(common))) = gen_nconc(old_layout,CONS(ENTITY,e,NIL));
  /* gen_nreverse(CONS(ENTITY,e,old_layout)); */
  area_size(type_area(entity_type(common))) = old_size+variable_size;
  AddEntityToDeclarations( e,module);
  return e;
}

References AddEntityToDeclarations(), area_layout, area_size, concatenate(), CONS, ENTITY, entity_storage, entity_type, gen_nconc(), is_storage_ram, is_type_variable, make_entity, make_ram(), make_storage(), make_type(), make_value_unknown(), module, module_local_name(), MODULE_SEP_STRING, NIL, pips_debug, storage_space_of_variable(), storage_undefined, strdup(), and type_area.

Referenced by create_externalized_function_common(), and create_new_scalar_common_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

create_new_integer_scalar_common_variable()

entity create_new_integer_scalar_common_variable	(	string	name,
		entity	module,
		entity	common
	)

Creates and declares a new integer scalar variable for a newly created common.

Parameters

name	ame
module	odule
common	ommon

Definition at line 228 of file phrase_distributor_control_code.c.

{
  return create_new_scalar_common_variable (name, module, common, MakeBasic(is_basic_int));
}

References create_new_scalar_common_variable(), is_basic_int, MakeBasic(), and module.

Referenced by make_global_common_and_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

create_new_scalar_common_variable()

entity create_new_scalar_common_variable	(	string	name,
		entity	module,
		entity	common,
		basic	b
	)

Creates and declares a new scalar variable for a newly created common.

Parameters

name	ame
module	odule
common	ommon

Definition at line 220 of file phrase_distributor_control_code.c.

{
  return create_new_common_variable( name,  module,  common, make_variable(b, NIL,NIL));
}

References create_new_common_variable(), make_variable(), module, and NIL.

Referenced by create_new_integer_scalar_common_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References code_declarations, concatenate(), CONS, copy_variable(), ENTITY, entity_domain, entity_initial, entity_type, entity_undefined, functional_parameters, gen_find_tabulated(), make_dummy_identifier(), make_entity, make_formal(), make_mode_reference(), make_parameter(), make_storage_formal(), make_type_variable(), make_value_unknown(), module, module_declarations(), module_name(), MODULE_SEP_STRING, new_variable, PARAMETER, pips_internal_error, strdup(), type_functional, and value_code.

Referenced by create_integer_parameter_for_new_module(), make_array_communication_module(), and make_scalar_communication_module().

Here is the call graph for this function:

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

References AddEntityToDeclarations(), area_layout, concatenate(), CONS, copy_type(), copy_value(), ENTITY, entity_global_name(), entity_initial, entity_local_name(), entity_storage, entity_type, gen_nconc(), gen_nreverse(), ifdebug, is_storage_ram, make_entity, make_ram(), make_storage(), MAP, module, module_local_name(), MODULE_SEP_STRING, new_variable, NIL, offset, pips_debug, ram_offset, storage_ram, strdup(), and type_area.

Referenced by make_array_communication_module(), make_scalar_communication_module(), make_start_ru_module(), and make_wait_ru_module().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_in_module()

entity entity_in_module	(	const char *	name,
		entity	module
	)

Return entity named name in specified module.

Is it the main module ?

Parameters

name	ame
module	odule

Definition at line 434 of file phrase_distributor_control_code.c.

{
  /* Is it the main module ? */
  if (strchr(entity_local_name(module),'%') != NULL) {
    return FindEntity(entity_local_name(module)+1,name);
  }
  else {
    return FindEntity(entity_local_name(module),name);
  }
 
}

References entity_local_name(), FindEntity(), and module.

Referenced by controlize_distribution(), make_array_communication_statement(), make_communication_statement(), make_scalar_communication_module(), and make_start_ru_module().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References asprintf, buffer, COMMON_PARAM_NAME, entity_local_name(), and strdup().

Referenced by create_externalized_function_common(), make_array_communication_statement(), make_communication_statement(), and make_start_ru_module().

Here is the call graph for this function:

Here is the caller graph for this function:

get_controlized_statement_comment()

string get_controlized_statement_comment

(

entity

function

)

Parameters

function

unction

Definition at line 329 of file phrase_distributor_control_code.c.

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

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

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

get_function_common_name()

static string get_function_common_name ( entity  function )

static

Definition at line 379 of file phrase_distributor_control_code.c.

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

References asprintf, buffer, entity_local_name(), FUNCTION_COMMON_NAME, and strdup().

Referenced by create_externalized_function_common().

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

References asprintf, buffer, entity_local_name(), FUNCTION_ID_NAME, and strdup().

Referenced by controlize_distribution(), make_global_common_and_initialize(), make_scalar_communication_module(), and make_start_ru_module().

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Referenced by controlize_distribution(), make_global_common_and_initialize(), and make_scalar_communication_module().

Here is the call graph for this function:

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

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

Referenced by controlize_distribution(), make_global_common_and_initialize(), and make_scalar_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);
}

References asprintf, buffer, RECEIVE_PARAMETER_MODULE_NAME, strdup(), and variable_to_string().

Referenced by get_receive_param_module_name(), and make_scalar_communication_modules().

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

References asprintf, buffer, SEND_PARAMETER_MODULE_NAME, strdup(), and variable_to_string().

Referenced by get_send_param_module_name(), and make_scalar_communication_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

get_unit_id_name()

static string get_unit_id_name ( int  unit )

static

Definition at line 404 of file phrase_distributor_control_code.c.

{
  char *buffer;
  asprintf(&buffer,UNIT_ID_NAME,unit);
  return strdup(buffer);
}

References asprintf, buffer, strdup(), and UNIT_ID_NAME.

Referenced by controlize_distribution(), and make_global_common_and_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

make_global_common_and_initialize()

static statement make_global_common_and_initialize ( entity  main_module, statement  module_stat, entity *  global_common, int  number_of_deployment_units, hash_table  ht_calls, hash_table  ht_in_regions, hash_table  ht_out_regions  )

static

Build and return CONTROL_DATA global common used to store global information on phrase distribution controlization and initialization of values contained in CONTROL_DATA common.

_in = regions_dup(load_statement_in_regions(s)); l_out = regions_dup(load_statement_out_regions(s));

Definition at line 452 of file phrase_distributor_control_code.c.

{
  list stats_list = CONS(STATEMENT,module_stat,NIL);
  statement new_stat;
  sequence new_sequence;
  int i;
  list l_in, l_out;
  const char* function_name;
  int id_function, id_param;
  entity units_nb_variable;
  entity functions_nb_variable;
 
  *global_common = make_new_common(CONTROL_DATA_COMMON_NAME,
                                     main_module);
  units_nb_variable = create_new_integer_scalar_common_variable(UNITS_NB_NAME,
                                                                main_module,
                                                                *global_common);
  new_stat = make_assignement_statement
    (units_nb_variable,
     int_to_expression (number_of_deployment_units), NULL);
  stats_list = CONS (STATEMENT, new_stat,stats_list);
 
  if (number_of_deployment_units > 1) {
    for (i=1; i<= number_of_deployment_units; i++) {
      entity unit_id_variable =
        create_new_integer_scalar_common_variable(get_unit_id_name(i),
                                                  main_module,
                                                  *global_common);
      new_stat = make_assignement_statement
        (unit_id_variable,
         int_to_expression (i), NULL);
      stats_list = CONS (STATEMENT, new_stat,stats_list);
    }
  }
 
 
  functions_nb_variable =
    create_new_integer_scalar_common_variable(FUNCTIONS_NB_NAME,
                                              main_module,
                                              *global_common);
 
  new_stat = make_assignement_statement
    (functions_nb_variable,
     int_to_expression (hash_table_entry_count(ht_calls)), NULL);
  stats_list = CONS (STATEMENT, new_stat,stats_list);
 
  id_function = 1;
 
  HASH_MAP (externalized_function, l_calls_for_function, {
   
    entity function = (entity)externalized_function;
    entity function_id_variable;
    function_name = entity_local_name(function);
    pips_debug(2, "Function [%s]\n",function_name);
     
    function_id_variable =
    create_new_integer_scalar_common_variable
    (get_function_id_name(function),
     main_module,
     *global_common);
    new_stat = make_assignement_statement
    (function_id_variable,
     int_to_expression (id_function++), NULL);
    stats_list = CONS (STATEMENT, new_stat,stats_list);
     
    id_param = 1;
   
    l_in = (list)hash_get(ht_in_regions,function);
    l_out = (list)hash_get(ht_out_regions,function);
 
    /*l_in = regions_dup(load_statement_in_regions(s));
      l_out = regions_dup(load_statement_out_regions(s));*/
     
    MAP (REGION, reg, {
      reference ref = effect_any_reference(reg);
      entity variable = reference_variable(ref);
      entity param_id_variable =
        create_new_integer_scalar_common_variable
        (get_in_param_id_name(variable,function),
         main_module,
         *global_common);
      new_stat = make_assignement_statement
        (param_id_variable,
         int_to_expression (id_param++), NULL);
      stats_list = CONS (STATEMENT, new_stat,stats_list);
    }, l_in);
   
    MAP (REGION, reg, {
      reference ref = effect_any_reference(reg);
      entity variable = reference_variable(ref);
      entity param_id_variable =
        create_new_integer_scalar_common_variable
        (get_out_param_id_name(variable,function),
         main_module,
         *global_common);
      new_stat = make_assignement_statement
        (param_id_variable,
         int_to_expression (id_param++), NULL);
      stats_list = CONS (STATEMENT, new_stat,stats_list);
    }, l_out);
   
  }, ht_calls);
 
  new_sequence = make_sequence (stats_list);
 
  return make_statement (entity_empty_label(),
                         STATEMENT_NUMBER_UNDEFINED,
                         STATEMENT_ORDERING_UNDEFINED,
                         empty_comments,
                         make_instruction (is_instruction_sequence,
                                           new_sequence),
                         NIL,NULL,
                         empty_extensions (), make_synchronization_none());
 
}

References CONS, CONTROL_DATA_COMMON_NAME, create_new_integer_scalar_common_variable(), effect_any_reference, empty_comments, empty_extensions(), entity_empty_label(), entity_local_name(), FUNCTIONS_NB_NAME, get_function_id_name(), get_in_param_id_name(), get_out_param_id_name(), get_unit_id_name(), hash_get(), HASH_MAP, hash_table_entry_count(), int_to_expression(), is_instruction_sequence, make_assignement_statement(), make_instruction(), make_new_common(), make_sequence(), make_statement(), make_synchronization_none(), MAP, NIL, pips_debug, ref, reference_variable, REGION, STATEMENT, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, and UNITS_NB_NAME.

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

phrase_distributor_control_code()

bool phrase_distributor_control_code

(

const char *

module_name

)

set and get the current properties concerning regions

get the resources

sets dynamic_area

Get the READ, WRITE, IN and OUT regions of the module

Now do the job

Display the statement before to check consistency

Check the coherency of data

Reorder the module, because new statements have been added

update/release resources

Parameters

module_name

odule_name

Definition at line 1039 of file phrase_distributor_control_code.c.

{
  statement module_stat;
  entity module;
 
  /* set and get the current properties concerning regions */
  set_bool_property("MUST_REGIONS", true);
  set_bool_property("EXACT_REGIONS", true);
  get_regions_properties();
 
  /* get the resources */
  module_stat = (statement) db_get_memory_resource(DBR_CODE,
                                                   module_name,
                                                   true);
 
  module = module_name_to_entity(module_name);
 
  set_current_module_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name)); // FI: redundant
 
  set_cumulated_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_proper_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  module_to_value_mappings(module);
 
  /* sets dynamic_area */
  if (entity_undefined_p(dynamic_area)) {       
    dynamic_area = FindOrCreateEntity(module_local_name(module),
                                      DYNAMIC_AREA_LOCAL_NAME);
  }
 
  debug_on("PHRASE_DISTRIBUTOR_DEBUG_LEVEL");
 
  /* Get the READ, WRITE, IN and OUT regions of the module
   */
  set_rw_effects((statement_effects)
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_in_effects((statement_effects)
                 db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
  set_out_effects((statement_effects)
                  db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
 
  /* Now do the job */
 
  pips_debug(2, "BEGIN of PHRASE_DISTRIBUTOR_CONTROL_CODE\n");
  module_stat = controlize_distribution (module_stat, module);
  pips_debug(2, "END of PHRASE_DISTRIBUTOR_CONTROL_CODE\n");
 
  /* Display the statement before to check consistency */
  ifdebug(4) {
    print_statement(module_stat);
  }
 
  /* Check the coherency of data */
 
  pips_assert("Statement structure is consistent after PHRASE_DISTRIBUTOR_CONTROL_CODE",
              gen_consistent_p((gen_chunk*)module_stat));
             
  pips_assert("Statement is consistent after PHRASE_DISTRIBUTOR_CONTROL_CODE",
               statement_consistent_p(module_stat));
 
 
  /* Reorder the module, because new statements have been added */ 
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
                         compute_callees(module_stat));
 
  /* update/release resources */
  reset_current_module_statement();
  reset_current_module_entity();
  dynamic_area = entity_undefined;
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  free_value_mappings();
 
  debug_off();
 
  return true;
}

References compute_callees(), controlize_distribution(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dynamic_area, DYNAMIC_AREA_LOCAL_NAME, entity_undefined, entity_undefined_p, FindOrCreateEntity(), free_value_mappings(), gen_consistent_p(), get_regions_properties(), ifdebug, module, module_local_name(), module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), pips_assert, pips_debug, print_statement(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_out_effects(), reset_proper_rw_effects(), reset_rw_effects(), set_bool_property(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_out_effects(), set_proper_rw_effects(), set_rw_effects(), and statement_consistent_p().

Here is the call 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);
}

References close_prettyprint(), code_declarations, db_build_file_resource_name(), DB_PUT_NEW_FILE_RESOURCE, empty_text(), ENTITY, entity_global_name(), entity_initial, fprint_environment(), get_current_module_entity(), ifdebug, init_prettyprint(), make_text_resource(), MAP, module, module_name(), module_statement, pips_debug, print_statement(), reset_current_module_entity(), set_current_module_entity(), text_module(), and value_code.

Referenced by make_array_communication_module(), make_scalar_communication_module(), make_start_ru_module(), and make_wait_ru_module().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

dynamic_area

entity dynamic_area = entity_undefined

static

Definition at line 1037 of file phrase_distributor_control_code.c.

Referenced by phrase_distributor_control_code().