externalization.c File Reference

#include "safescale.h"
#include "workspace-util.h"
#include "text-util.h"
#include "syntheses.h"
#include "preprocessor.h"

Include dependency graph for externalization.c:

Go to the source code of this file.

Functions
static void	check_if_statement_contains_comment (statement s, void *a_context)
	lint More...
static list	get_statements_with_comments_containing (string comment_portion, statement stat)
	Building a list with statements containing comments. More...
static 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_TOP Set the number of statements of this externalizable statement. More...
static void	search_sequence_containing (statement s, void *a_context)
	Get sequence containing a searched context. More...
static statement	sequence_statement_containing (statement root_statement, statement searched_stat)
	Get statement containing a searched statement. More...
static list	compute_regions_union (list l_in, list l_out)
	Compute union of exact regions. More...
static bool	internal_compute_distribution_context (statement externalized_code, hash_table *ht_params, hash_table *ht_private, hash_table *ht_in_regions, hash_table *ht_out_regions, void *key_value)
	Compute internal distribution context for statement externalized_code. More...
static 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)
	Compute distribution context for statement externalized_code. More...
static entity	create_parameter_variable_for_new_module (entity a_variable, string new_name, string new_module_name, entity module, int param_nb)
	Create a variable declared as a parameter in specified module. More...
static entity	create_private_variable_for_new_module (entity a_variable, string new_name, string new_module_name, entity module)
	Create a private variable in specified module. More...
static string	get_externalized_function_param_name (entity variable, int param_nb)
	Return EXTERNALIZED_FUNCTION_PARAM_NAME. More...
static string	get_externalized_function_private_param_name (entity variable)
	Return EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME. More...
static void	add_parameter_variable_to_module (reference ref, entity module, statement stat, string new_module_name, int param_nb)
	Declare in the newly created module a new variable and replace all occurences to the old variable by the new created. More...
static void	add_private_variable_to_module (reference ref, entity module, statement stat, string new_module_name)
	Declare in the newly created module a new variable and replace all occurences to the old variable by the new created. More...
static list	references_for_regions (list l_regions)
	Return a list of references corresponding to a list of regions. More...
static entity	create_module_with_statement (statement stat, string new_module_name, list l_params, list l_priv)
	Dynamically build a new module with specified statement. More...
static void	replace_in_sequence_statement_with (statement old_stat, statement new_stat, statement root_stat)
	Replace statement old_stat by statement new_stat and assert that this statement is contained in a sequence. More...
static void	distribute_code (string function_name, statement externalized_code, statement module_stat, list l_params, list l_priv)
	Externalize a specified code portion. More...
static void	distribute (statement module_stat, entity module)
	Distribute for main module module with root statement stat. More...
bool	safescale_distributor (const char *module_name)
	externalization.c More...

Variables
static entity	dynamic_area = entity_undefined
	Main phase for block code externalization. More...

Function Documentation

add_parameter_variable_to_module()

static void add_parameter_variable_to_module ( reference  ref, entity  module, statement  stat, string  new_module_name, int  param_nb  )

static

Declare in the newly created module a new variable and replace all occurences to the old variable by the new created.

Assert that entity represent a value code

Get the variable name

Definition at line 511 of file externalization.c.

{
  parameter new_parameter;
  list module_declarations;
  list module_parameters;
  entity new_variable;
  string variable_name;
 
  pips_debug(2, "Registering parameter: %s\n", entity_local_name(reference_variable(ref)));
 
  /* Assert that entity represent a value code */
  pips_assert("It is a module", entity_module_p(module));
 
  /* Get the variable name */
  variable_name = get_externalized_function_param_name(reference_variable(ref), param_nb); 
 
  new_variable = create_parameter_variable_for_new_module(reference_variable(ref), variable_name, new_module_name, module, param_nb);  
  replace_reference(stat, ref, new_variable);  
  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(is_mode_reference, UU), make_dummy_unknown()); //FI: could be make_dummy_identifier(new_variable)
  module_parameters = module_functional_parameters(module);
  module_functional_parameters(module) = CONS(PARAMETER, new_parameter, module_parameters);
}

References code_declarations, CONS, create_parameter_variable_for_new_module(), ENTITY, entity_initial, entity_local_name(), entity_module_p(), entity_type, get_externalized_function_param_name(), is_mode_reference, make_dummy_unknown(), make_mode(), make_parameter(), module, module_declarations(), module_functional_parameters, new_variable, PARAMETER, pips_assert, pips_debug, ref, reference_variable, replace_reference(), UU, value_code, and variable_name().

Referenced by create_module_with_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

add_private_variable_to_module()

static void add_private_variable_to_module ( reference  ref, entity  module, statement  stat, string  new_module_name  )

static

Declare in the newly created module a new variable and replace all occurences to the old variable by the new created.

Assert that entity represent a value code

Get the variable name

Creates the variable

Definition at line 541 of file externalization.c.

{
  list module_declarations;
  entity new_variable;
  string variable_name;
  
  pips_debug(2, "Registering private variable: %s\n", entity_local_name(reference_variable(ref)));
  
  /* Assert that entity represent a value code */
  pips_assert("It is a module", entity_module_p(module));
  
  /* Get the variable name */
  variable_name = get_externalized_function_private_param_name(reference_variable(ref)); 
 
  /* Creates the variable */
  new_variable = create_private_variable_for_new_module(reference_variable(ref), variable_name, new_module_name, module);  
  
  replace_reference(stat, ref, new_variable);    
  module_declarations = code_declarations(value_code(entity_initial(module)));
  code_declarations(value_code(entity_initial(module))) = CONS(ENTITY, new_variable, module_declarations);
  
}

References code_declarations, CONS, create_private_variable_for_new_module(), ENTITY, entity_initial, entity_local_name(), entity_module_p(), get_externalized_function_private_param_name(), module, module_declarations(), new_variable, pips_assert, pips_debug, ref, reference_variable, replace_reference(), value_code, and variable_name().

Referenced by create_module_with_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

check_if_statement_contains_comment()

static void check_if_statement_contains_comment ( statement  s, void *  a_context  )

static

lint

Adding in the statement containing comments in the list of statements

Definition at line 43 of file externalization.c.

{
  statement_checking_context* context = (statement_checking_context*)a_context;
  string comments;
 
  if (!statement_with_empty_comment_p(s)) 
  {    
    comments = strdup(statement_comments(s));
    
    if (strstr(comments, context->searched_string) != NULL) 
    {
      context->list_of_statements = CONS(STATEMENT, s, context->list_of_statements);
    }
 
    free(comments);
  } 
}

References CONS, free(), STATEMENT, statement_comments, statement_with_empty_comment_p(), and strdup().

Referenced by get_statements_with_comments_containing().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_distribution_context()

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

static

Compute distribution context for statement externalized_code.

Init hashtables

Register new externalized function

Definition at line 366 of file externalization.c.

{
  bool returned_value = true;
 
  pips_debug(5, "[BEGIN] compute_distribution_context for %s: \n", entity_local_name(module));
 
  /* Init hashtables */
  *ht_stats = hash_table_make(hash_pointer, 0);
  *ht_params = hash_table_make(hash_pointer, 0);
  *ht_private = hash_table_make(hash_pointer, 0);
  *ht_in_regions = hash_table_make(hash_pointer, 0);
  *ht_out_regions = hash_table_make(hash_pointer, 0);
 
  MAP(STATEMENT, s, {
                      statement externalized_code = NULL;
                      int stats_nb;
                      string function_name = get_externalized_and_analyzed_function_name(s, &stats_nb);
 
                      pips_debug(5, "Funtion name: %s\n", function_name);
                      pips_debug(5, "Number of statements: %d\n", 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 distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_regions_union()

static list compute_regions_union ( list  l_in, list  l_out  )

static

Compute union of exact regions.

Definition at line 192 of file externalization.c.

{
  list l_union = gen_copy_seq(l_in);
 
  pips_debug(4, "BEGIN of computing regions UNION\n");
 
  MAP(REGION, reg, {
                     entity e = region_entity(reg);
                     bool is_already_present = false;
                     region reg_already_present = NULL;
 
                     MAP (REGION, union_reg, {
                                               entity e2 = region_entity(union_reg);
 
                                               if (same_entity_p(e, e2)) 
                                               {
                                                 is_already_present = true;
                                                 reg_already_present = union_reg;
                                               }
                                             }, l_union);
 
                    if (is_already_present) 
                    {
                      if (region_scalar_p(reg)) 
                      {
                        pips_debug(6, "Found SCALAR region already present [%s]. Ignored.\n", entity_local_name(e));
                      }
                      else 
                      {
                        list new_regions;
 
                        pips_debug(6, "Found ARRAY region already present [%s].\n", entity_local_name(e));
                        pips_debug(6, "Making UNION of:\n");
 
                        print_region(reg);
                        pips_debug(6, "and:\n");
                        print_region(reg_already_present);      
                        new_regions = region_must_union(reg,reg_already_present);
 
                        pips_debug(6, "Getting:\n");
 
                        print_regions(new_regions);
 
                        if (gen_length(new_regions) > 1) 
                        {
                          pips_internal_error("Regions union must refer to only ONE region !");
                        }
                        else 
                        {
                          gen_remove(&l_union, reg_already_present);
                          l_union = CONS(REGION, REGION(gen_nth(0, new_regions)), l_union);
                        }
                      }
                    }
                    else 
                    {
                      pips_debug(6, "Adding region for [%s]\n", entity_local_name(e));
                      l_union = CONS(REGION, reg, l_union);
                    }
                  }, l_out);
 
  pips_debug(4, "END of computing regions UNION\n");
 
  return l_union;
}

References CONS, entity_local_name(), gen_copy_seq(), gen_length(), gen_nth(), gen_remove(), MAP, pips_debug, pips_internal_error, print_region, print_regions(), region, REGION, region_entity, region_must_union(), region_scalar_p, and same_entity_p().

Referenced by internal_compute_distribution_context().

Here is the call graph for this function:

Here is the caller graph for this function:

create_module_with_statement()

static entity create_module_with_statement ( statement  stat, string  new_module_name, list  l_params, list  l_priv  )

static

Dynamically build a new module with specified statement.

Deal with private variables

Deal with parameter variables

Definition at line 587 of file externalization.c.

{
  entity new_module;
  //string source_file;
  //text text_code;
  int param_nb = 0;
 
  pips_debug(5, "[BEGIN] create_module_with_statement\n");
  pips_debug(2, "Creating new module: [%s]\n", new_module_name);
 
  new_module = make_empty_subroutine(new_module_name,copy_language(module_language(get_current_module_entity())));
  
  /* Deal with private variables */
  MAP(REFERENCE, ref, {
                        add_private_variable_to_module(ref, new_module, stat, new_module_name);
                      }, references_for_regions(l_priv));
  
  /* Deal with parameter variables */ 
  param_nb = gen_length(l_params);
 
  MAP(REFERENCE, ref, {
                        add_parameter_variable_to_module(ref, new_module, stat, new_module_name, param_nb);
                        param_nb--;
                      }, references_for_regions(l_params));
  
  pips_debug(2, "Making new module: [%s]\n", new_module_name);
 
  ifdebug(5)
  {
    pips_debug(5, "With statement: \n");
    print_statement(stat);
  }
  
  add_new_module(new_module_name, new_module, stat,
                 prettyprint_language_is_fortran_p ());
  
  pips_debug(5, "[END] create_module_with_statement\n");
 
  return new_module;
}

References add_new_module(), add_parameter_variable_to_module(), add_private_variable_to_module(), copy_language(), gen_length(), get_current_module_entity(), ifdebug, make_empty_subroutine(), MAP, module_language, pips_debug, prettyprint_language_is_fortran_p(), print_statement(), ref, REFERENCE, and references_for_regions().

Referenced by distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

create_parameter_variable_for_new_module()

static entity create_parameter_variable_for_new_module ( entity  a_variable, string  new_name, string  new_module_name, entity  module, int  param_nb  )

static

Create a variable declared as a parameter in specified module.

Test if entity exists and create it if not

Definition at line 430 of file externalization.c.

{
  entity new_variable;
 
  /* Test if entity exists and create it if not */
  if ((gen_find_tabulated(concatenate(new_module_name, MODULE_SEP_STRING, new_name, NULL), entity_domain)) == entity_undefined) 
  { 
    new_variable = make_entity(strdup(concatenate(new_module_name, MODULE_SEP_STRING, new_name, NULL)), copy_type(entity_type(a_variable)), make_storage_formal(make_formal(module, param_nb)), copy_value(entity_initial(a_variable)));
 
    return new_variable;
  }
  else 
  {
    pips_internal_error("Entity already exist: %s", new_name);
  
    return NULL;
  }
}

References a_variable, concatenate(), copy_type(), copy_value(), entity_domain, entity_initial, entity_type, entity_undefined, gen_find_tabulated(), make_entity, make_formal(), make_storage_formal(), module, MODULE_SEP_STRING, new_variable, pips_internal_error, and strdup().

Referenced by add_parameter_variable_to_module().

Here is the call graph for this function:

Here is the caller graph for this function:

create_private_variable_for_new_module()

static entity create_private_variable_for_new_module ( entity  a_variable, string  new_name, string  new_module_name, entity  module  )

static

Create a private variable in specified module.

Test if entity exists and create it if not

Definition at line 453 of file externalization.c.

{
  entity new_variable;
  entity a;
  basic base;
  
  /* Test if entity exists and create it if not */
  if ((gen_find_tabulated(concatenate(new_module_name, MODULE_SEP_STRING, new_name, NULL), entity_domain)) == entity_undefined) 
  { 
    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;
  }
}

References a_variable, add_variable_to_area(), base, basic_tag, concatenate(), copy_type(), copy_value(), DYNAMIC_AREA_LOCAL_NAME, entity_domain, entity_global_name(), entity_initial, entity_storage, entity_type, entity_undefined, FindEntity(), gen_find_tabulated(), is_basic_overloaded, is_storage_ram, make_entity, make_ram(), make_storage(), module, MODULE_SEP_STRING, new_variable, NIL, pips_debug, pips_internal_error, storage_undefined, strdup(), type_variable, and variable_basic.

Referenced by add_private_variable_to_module().

Here is the call graph for this function:

Here is the caller graph for this function:

distribute()

static void distribute ( statement  module_stat, entity  module  )

static

Distribute for main module module with root statement stat.

Definition at line 741 of file externalization.c.

{
  list l_stats = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_ANALYZED_TOP, module_stat);
  hash_table ht_stats;
  hash_table ht_params;
  hash_table ht_private;
  hash_table ht_in_regions;
  hash_table ht_out_regions;
 
  pips_debug(5, "[BEGIN] distribute\n");
  pips_debug(5, "Number of analyzed statements to distribute: %td\n", gen_length(l_stats));
 
  compute_distribution_context(l_stats, module_stat, module, &ht_stats, &ht_params, &ht_private, &ht_in_regions, &ht_out_regions);
 
  HASH_MAP(function_name, stat, {
                                  distribute_code(function_name, stat, module_stat, hash_get(ht_params, function_name), hash_get(ht_private, function_name));
                                }, ht_stats);
 
  hash_table_free(ht_stats);
  hash_table_free(ht_params);
  hash_table_free(ht_private);
  hash_table_free(ht_in_regions);
  hash_table_free(ht_out_regions);
 
  pips_debug(5, "[END] distribute\n");
}

References compute_distribution_context(), distribute_code(), EXTERNALIZED_CODE_PRAGMA_ANALYZED_TOP, gen_length(), get_statements_with_comments_containing(), hash_get(), HASH_MAP, hash_table_free(), module, and pips_debug.

Referenced by safescale_distributor().

Here is the call graph for this function:

Here is the caller graph for this function:

distribute_code()

static void distribute_code ( string  function_name, statement  externalized_code, statement  module_stat, list  l_params, list  l_priv  )

static

Externalize a specified code portion.

Insert an analyzed tag

Definition at line 677 of file externalization.c.

{
  entity new_module = create_module_with_statement(externalized_code, function_name, l_params, l_priv);
  statement call_statement;
  list call_params = NIL;
  string call_comments;
 
  pips_debug(5, "[BEGIN] distribute_code\n");
 
  MAP(REFERENCE, ref, {
                        call_params = CONS(EXPRESSION, make_entity_expression(reference_variable(ref), NIL), call_params);
                      }, references_for_regions(l_params));
  
  /* Insert an analyzed tag */ 
  {
    char* new_tag = malloc(256);
 
    sprintf(new_tag, strdup(concatenate("\n! ", EXTERNALIZED_CODE_PRAGMA_CALL, "\n", NULL)), function_name);
    call_comments = strdup(new_tag);
  }
 
  call_statement = make_statement(entity_empty_label(),
                                  statement_number(externalized_code),
                                  statement_ordering(externalized_code),
                                  call_comments,
                                  make_instruction(is_instruction_call,
                                                   make_call(new_module,
                                                             call_params)),
                                  NIL,
                                  NULL,
                                  statement_extensions (externalized_code), make_synchronization_none());
  
  pips_debug(7, "BEFORE REPLACING\n");
  pips_debug(7, "externalized_code=\n");
  print_statement(externalized_code);
  pips_debug(7, "call_statement=\n");
  print_statement(call_statement);
  pips_debug(7, "module_stat=\n");
  print_statement(module_stat);
 
  replace_in_sequence_statement_with(externalized_code, call_statement, module_stat);
 
  pips_debug(7, "AFTER REPLACING\n");
  pips_debug(7, "externalized_code=\n");
  print_statement(externalized_code);
  pips_debug(7, "call_statement=\n");
  print_statement(call_statement);
  pips_debug(7, "module_stat=\n");
  print_statement(module_stat);
 
  pips_assert("Module structure is consistent after DISTRIBUTE_CODE", gen_consistent_p((gen_chunk*) new_module));             
  pips_assert("Statement structure is consistent after DISTRIBUTE_CODE", gen_consistent_p((gen_chunk*) externalized_code));           
  pips_assert("Statement is consistent after DISTRIBUTE_CODE", statement_consistent_p(externalized_code));
  
  pips_debug(7, "Code distribution for : [%s] is DONE\n", function_name);
  pips_debug(5, "[END] distribute_code\n");
 
  free(call_comments);
}

References concatenate(), CONS, create_module_with_statement(), entity_empty_label(), EXPRESSION, EXTERNALIZED_CODE_PRAGMA_CALL, free(), gen_consistent_p(), is_instruction_call, make_call(), make_entity_expression(), make_instruction(), make_statement(), make_synchronization_none(), malloc(), MAP, NIL, pips_assert, pips_debug, print_statement(), ref, REFERENCE, reference_variable, references_for_regions(), replace_in_sequence_statement_with(), statement_consistent_p(), statement_extensions, statement_number, statement_ordering, and strdup().

Referenced by distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

get_externalized_and_analyzed_function_name()

static string get_externalized_and_analyzed_function_name ( statement  stat, int *  stats_nb  )

static

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

Definition at line 100 of file externalization.c.

{
  string comments;
  string searched_string;
  string comment_portion = strdup(EXTERNALIZED_CODE_PRAGMA_ANALYZED_TOP);
  char *function_name = NULL;
  char *next_line;
  instruction i = statement_instruction(stat);
 
  pips_debug(7, "Statement to be processed: ");
  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);
          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);
    }
 
    free(searched_string);
    free(comments);
  }
  
  free(comment_portion);
 
  return function_name;
}

References EXTERNALIZED_CODE_PRAGMA_ANALYZED_TOP, free(), gen_nth(), instruction_sequence, instruction_tag, is_instruction_sequence, malloc(), pips_debug, print_statement(), 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_param_name()

static string get_externalized_function_param_name ( entity  variable, int  param_nb  )

static

Return EXTERNALIZED_FUNCTION_PARAM_NAME.

Definition at line 484 of file externalization.c.

{
  char buffer[256];
 
  sprintf(buffer, EXTERNALIZED_FUNCTION_PARAM_NAME, entity_user_name(variable), param_nb);
 
  return strdup(buffer);
}

References buffer, entity_user_name(), EXTERNALIZED_FUNCTION_PARAM_NAME, and strdup().

Referenced by add_parameter_variable_to_module().

Here is the call graph for this function:

Here is the caller graph for this function:

get_externalized_function_private_param_name()

static string get_externalized_function_private_param_name ( entity  variable )

static

Return EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME.

Definition at line 497 of file externalization.c.

{
  char buffer[256];
 
  sprintf(buffer, EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME, entity_user_name(variable));
 
  return strdup(buffer);
}

References buffer, entity_user_name(), EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME, and strdup().

Referenced by add_private_variable_to_module().

Here is the call graph for this function:

Here is the caller graph for this function:

get_statements_with_comments_containing()

static list get_statements_with_comments_containing ( string  comment_portion, statement  stat  )

static

Building a list with statements containing comments.

Set searched string

Reset and get list of statements

Definition at line 65 of file externalization.c.

{
  string percent;
  statement_checking_context context;
 
  /* Set searched string */
  context.searched_string = strdup(comment_portion);
  percent = strstr(context.searched_string, "%s");
 
  if (percent == NULL)
    pips_user_error("Malformed statement comment to search. Should be of the form 'BLAH_%%s'\n");
 
  *percent = '\0';
 
  /* Reset and get list of statements */
  context.list_of_statements = NIL;
 
  ifdebug(5) {
    pips_debug(5, "Searching statements with comments: %s\n", context.searched_string);      
    pips_debug(5, "In statement:\n");      
    print_statement(stat);
  }
 
  gen_context_recurse(stat, &context, statement_domain, gen_true2, check_if_statement_contains_comment);
  
  free(context.searched_string);
 
  return context.list_of_statements;
}

References check_if_statement_contains_comment(), free(), gen_context_recurse, gen_true2(), ifdebug, NIL, pips_debug, pips_user_error, print_statement(), statement_domain, and strdup().

Referenced by distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

internal_compute_distribution_context()

static bool internal_compute_distribution_context ( statement  externalized_code, hash_table *  ht_params, hash_table *  ht_private, hash_table *  ht_in_regions, hash_table *  ht_out_regions, void *  key_value  )

static

Compute internal distribution context for statement externalized_code.

Store results in hash_tables

Definition at line 262 of file externalization.c.

{
  bool returned_value = true;
  list l_read, l_write, l_in, l_out;
  list l_params = NIL;
  list l_priv = NIL;
 
  pips_debug(6, "Compute regions\n");
  
  l_write = regions_dup(regions_write_regions(load_statement_local_regions(externalized_code))); 
  l_read = regions_dup(regions_read_regions(load_statement_local_regions(externalized_code))); 
  l_in = regions_dup(load_statement_in_regions(externalized_code));
  l_out = regions_dup(load_statement_out_regions(externalized_code));
  
  ifdebug(6) 
  {
    pips_debug(6, "READ regions: \n");
    print_regions(l_read);
    pips_debug(6, "WRITE regions: \n");
    print_regions(l_write);
  }
  
  l_params = compute_regions_union(l_in, l_out);    
  l_in = regions_dup(load_statement_in_regions(externalized_code));
  l_out = regions_dup(load_statement_out_regions(externalized_code));
  l_priv = RegionsEntitiesInfDifference(l_write, l_in, w_r_combinable_p);
  l_priv = RegionsEntitiesInfDifference(l_priv, l_out, w_w_combinable_p);    
  l_in = regions_dup(load_statement_in_regions(externalized_code));
  l_out = regions_dup(load_statement_out_regions(externalized_code));
 
  gen_sort_list(l_in, (gen_cmp_func_t)compare_effect_reference);
  gen_sort_list(l_out, (gen_cmp_func_t)compare_effect_reference);
  gen_sort_list(l_params, (gen_cmp_func_t)compare_effect_reference);
  gen_sort_list(l_priv, (gen_cmp_func_t)compare_effect_reference);
 
  ifdebug(2)
  {
    pips_debug(2, "IN regions: \n");
    print_regions(l_in);
    pips_debug(2, "OUT regions: \n");
    print_regions(l_out);
    pips_debug(2, "Params regions: \n");
    print_regions(l_params);
    pips_debug(2, "Private regions: \n");
    print_regions(l_priv);
  }
 
  /* Store results in hash_tables */
  pips_debug(2, "Storing in hash_tables with key %s: \n", (string)key_value);
  pips_debug(5, "Storing in ht_param: \n");
 
  if (!hash_defined_p(*ht_params, key_value)) 
  {
    hash_put(*ht_params, key_value, l_params);
  }
  else 
  {
    pips_user_warning("Multiply defined value in PARAMS hash_table!\n");    
    returned_value = false;
  }
  
  pips_debug(5, "Storing in ht_private: \n");
 
  if (!hash_defined_p(*ht_private, key_value)) 
  {
    hash_put(*ht_private, key_value, l_priv);
  }
  else 
  {
    pips_user_warning("Multiply defined value in PRIVATE hash_table!\n");    
    returned_value = false;
  }
  
  pips_debug(5, "Storing in ht_in_regions: \n");
 
  if (!hash_defined_p(*ht_in_regions, key_value)) 
  {
    hash_put(*ht_in_regions, key_value, l_in);
  }
  else 
  {
    pips_user_warning("Multiply defined value in IN_REGIONS hash_table!\n");    
    returned_value = false;
  }
  
  pips_debug(5, "Storing in ht_out_regions: \n");
 
  if (!hash_defined_p(*ht_out_regions, key_value)) 
  {
    hash_put(*ht_out_regions, key_value, l_out);
  }
  else 
  {
    pips_user_warning("Multiply defined value in OUT_REGIONS hash_table!\n");    
    returned_value = false;
  }
 
  return returned_value;
}

References compare_effect_reference(), compute_regions_union(), gen_sort_list(), hash_defined_p(), hash_put(), ifdebug, load_statement_in_regions(), load_statement_local_regions(), load_statement_out_regions(), NIL, pips_debug, pips_user_warning, print_regions(), regions_dup(), regions_read_regions(), regions_write_regions(), RegionsEntitiesInfDifference(), w_r_combinable_p(), and w_w_combinable_p().

Referenced by compute_distribution_context().

Here is the call graph for this function:

Here is the caller graph for this function:

references_for_regions()

static list references_for_regions ( list  l_regions )

static

Return a list of references corresponding to a list of regions.

Definition at line 568 of file externalization.c.

{
  list l_ref = NIL;
  
  MAP(EFFECT, reg, {
                     reference ref = effect_any_reference(reg);
 
                     l_ref = CONS(REFERENCE, ref, l_ref);
                     print_reference(ref);
                     pips_debug(4,"Entity: %s\n", entity_local_name(reference_variable(ref)));
                   }, l_regions);
 
  return l_ref;
}

References CONS, EFFECT, effect_any_reference, entity_local_name(), MAP, NIL, pips_debug, print_reference(), ref, REFERENCE, and reference_variable.

Referenced by create_module_with_statement(), and distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_in_sequence_statement_with()

static void replace_in_sequence_statement_with ( statement  old_stat, statement  new_stat, statement  root_stat  )

static

Replace statement old_stat by statement new_stat and assert that this statement is contained in a sequence.

Definition at line 632 of file externalization.c.

{
  statement sequence_statement = sequence_statement_containing(root_stat, old_stat);
  list stats_list = sequence_statements(instruction_sequence(statement_instruction(sequence_statement))); 
  list new_stats_list = NIL;
 
  pips_debug(5, "BEGIN replace_in_sequence_statement_with:\n");
  pips_assert("Statement is contained in a sequence", sequence_statement != NULL);
 
  MAP(STATEMENT, s, {
                      pips_debug(7, "Iterate on statement:\n");
 
                      print_statement(s);    
                     
                      if (s == old_stat) 
                      {
                        pips_debug(7, "Replace this statement:\n");
 
                        new_stats_list = CONS(STATEMENT, new_stat, new_stats_list);
                      }
                    else 
                    {
                      pips_debug(7, "Keep this statement:\n");
 
                      new_stats_list = CONS(STATEMENT, s, new_stats_list);
                    }
                  }, stats_list);
 
  sequence_statements(instruction_sequence(statement_instruction(sequence_statement))) = gen_nreverse(new_stats_list);
 
  ifdebug(7) 
  {
    pips_debug(7, "I've got this for the sequence\n");
    print_statement(sequence_statement);    
    pips_debug(7, "I've got this for the root statement\n");
    print_statement(root_stat);    
  }
 
  pips_debug(5, "END replace_in_sequence_statement_with:\n");
}

References CONS, gen_nreverse(), ifdebug, instruction_sequence, MAP, NIL, pips_assert, pips_debug, print_statement(), sequence_statement_containing(), sequence_statements, STATEMENT, and statement_instruction.

Referenced by distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

safescale_distributor()

bool safescale_distributor

(

const char *

module_name

)

externalization.c

Set and get the current properties concerning regions

Get the resources

Set dynamic_area

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

Do the job

Restructuring code to avoid imbricated sequences if some portions are found to allow more than one INIT

Reorder the module because new statements have been added

Update/release resources

Parameters

module_name

odule_name

Definition at line 774 of file externalization.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));
 
  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);
  
  /* Set dynamic_area */
  if (entity_undefined_p(dynamic_area)) 
  {     
    dynamic_area = FindOrCreateEntity(module_local_name(module), DYNAMIC_AREA_LOCAL_NAME); 
  }
 
  debug_on("SAFESCALE_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));
 
  /* Do the job */
  pips_debug(2, "BEGIN of SAFESCALE_DISTRIBUTOR\n");
  /* Restructuring code to avoid imbricated sequences if some portions are found to allow more than one INIT */
  simple_restructure_statement(module_stat);
  distribute(module_stat, module);
  pips_debug(2, "END of SAFESCALE_DISTRIBUTOR\n");
 
  print_statement(module_stat);
 
  pips_assert("Statement structure is consistent after SAFESCALE_DISTRIBUTOR", gen_consistent_p((gen_chunk*) module_stat));
  pips_assert("Statement is consistent after SAFESCALE_DISTRIBUTOR", 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(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, distribute(), dynamic_area, DYNAMIC_AREA_LOCAL_NAME, entity_undefined, entity_undefined_p, FindOrCreateEntity(), free_value_mappings(), gen_consistent_p(), get_regions_properties(), 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(), simple_restructure_statement(), and statement_consistent_p().

Here is the call graph for this function:

search_sequence_containing()

static void search_sequence_containing ( statement  s, void *  a_context  )

static

Get sequence containing a searched context.

Definition at line 156 of file externalization.c.

{
  sequence_searching_context* context = (sequence_searching_context*)a_context;
  instruction i = statement_instruction(s);
  
  if (instruction_tag(i) == is_instruction_sequence) 
  {
    MAP (STATEMENT, s2, {
                          if (s2 == context->searched_statement) 
                          {
                            context->found_sequence_statement = s;
                          }
    }, sequence_statements(instruction_sequence(i)));
  }
}

References instruction_sequence, instruction_tag, is_instruction_sequence, MAP, sequence_statements, STATEMENT, and statement_instruction.

Referenced by sequence_statement_containing().

Here is the caller graph for this function:

sequence_statement_containing()

static statement sequence_statement_containing ( statement  root_statement, statement  searched_stat  )

static

Get statement containing a searched statement.

Definition at line 176 of file externalization.c.

{
  sequence_searching_context context;
 
  context.searched_statement = searched_stat;
  context.found_sequence_statement = NULL;
 
  gen_context_recurse(root_statement, &context, statement_domain, gen_true2, search_sequence_containing);
 
  return context.found_sequence_statement;
}

References gen_context_recurse, gen_true2(), search_sequence_containing(), and statement_domain.

Referenced by compute_distribution_context(), and replace_in_sequence_statement_with().

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

Main phase for block code externalization.

Definition at line 772 of file externalization.c.

Referenced by safescale_distributor().