phrase_distributor.c File Reference

#include <stdio.h>
#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "resources.h"
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "syntheses.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "text-util.h"
#include "properties.h"
#include "dg.h"
#include "transformer.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 "preprocessor.h"
#include "pipsmake.h"
#include "phrase_tools.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "phrase_distribution.h"

Include dependency graph for phrase_distributor.c:

Go to the source code of this file.

Typedefs
typedef dg_arc_label	arc_label
typedef dg_vertex_label	vertex_label

Functions
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...
string	get_function_name_by_searching_tag (statement stat, const char *tag)
	Return the identified function name of the externalized portion of code by searching comment matching tag. More...
static void	remove_begin_tag (statement stat, string function_name)
	Remove begin tag for statement stat and function function_name. More...
static void	remove_end_tag (statement stat, string function_name)
	Remove end tag for statement stat and function function_name. More...
static statement	isolate_code_portion (statement begin_tag_statement, statement end_tag_statement, statement sequence_statement)
	At this point, we have a sequence statement sequence_statement which contains a statement with a begin tag and a statement with a end tag. More...
list	identify_analyzed_statements_to_distribute (statement stat)
	This function return a list of statements that were previously marked for externalization during phase PHRASE_DISTRIBUTOR_INIT. More...
static list	identify_statements_to_distribute (statement module_stat)
	This function return a list of statements that are marked for externalization. More...
static void	distribute_code (string function_name, statement externalized_code, statement module_stat, list l_params, list l_priv)
	This function is called after identification and isolation of a portion of code to externalize. More...
static void	distribute (statement module_stat, entity module)
	Main function for PHRASE_DISTRIBUTION: phrase distribution for main module module, with root statement stat. More...
static void	prepare_distribute (statement module_stat)
	Main function for PHRASE_DISTRIBUTION_INIT: phrase distribution for module module_stat. More...
static string	get_externalized_function_param_name (entity variable, int param_nb)
static string	get_externalized_function_private_param_name (entity variable)
static entity	create_parameter_variable_for_new_module (entity a_variable, string new_name, string new_module_name, entity module, int param_nb)
	Creates a variable declared as a parameter in specified module. More...
entity	create_private_variable_for_new_module (entity a_variable, const char *new_name, const char *new_module_name, entity module)
	Creates a private variable in specified module. More...
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 (which will be a parameter of the module), and replace all occurences to the old variable by the new created. More...
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 (which will be a private to the module), and replace all occurences to the old variable by the new created. More...
bool	phrase_distributor_init (const char *module_name)
bool	phrase_distributor (const char *module_name)

Variables
static entity	dynamic_area = entity_undefined

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Definition at line 50 of file phrase_distributor.c.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 51 of file phrase_distributor.c.

Function Documentation

add_parameter_variable_to_module()

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 (which will be a parameter of the module), and replace all occurences to the old variable by the new created.

Assert that entity represent a value code

Get the variable name

trdup("")

Parameters

ref	ef
module	odule
stat	tat
new_module_name	Statement of the new module
param_nb	aram_nb

Definition at line 633 of file phrase_distributor.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_reference(),
                                  /*strdup("")*/make_dummy_identifier(new_variable));
  
  module_parameters = functional_parameters(type_functional(entity_type(module)));
 
  functional_parameters(type_functional(entity_type(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, functional_parameters, get_externalized_function_param_name(), make_dummy_identifier(), make_mode_reference(), make_parameter(), module, module_declarations(), new_variable, PARAMETER, pips_assert, pips_debug, ref, reference_variable, replace_reference(), type_functional, 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()

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 (which will be a private to the module), 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

Parameters

ref	ef
module	odule
stat	tat
new_module_name	Statement of the new module

Definition at line 683 of file phrase_distributor.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:

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.

After creation, return it.

Deal with private variables

Definition at line 720 of file phrase_distributor.c.

{
    entity new_module;
    int param_nb = 0;
 
    pips_debug(2, "Creating new module: [%s]\n", new_module_name);
 
    new_module = make_empty_subroutine(new_module_name,make_language_unknown());
 
    /* Deal with private variables */
    FOREACH (REFERENCE, ref, references_for_regions (l_priv)){
        add_private_variable_to_module (ref, 
                new_module, 
                stat, 
                new_module_name);
    }
 
    // Deal with parameters variables 
    param_nb = gen_length(l_params);
    FOREACH (REFERENCE, ref, references_for_regions(l_params)){
        add_parameter_variable_to_module (ref, 
                new_module, 
                stat, 
                new_module_name, 
                param_nb);
        param_nb--;
    }
 
    pips_debug(2, "Making new module: [%s]\n", new_module_name);
    ifdebug(5) {
        pips_debug(5, "With statement: \n");
        print_statement (stat);
    }
    text t = text_named_module(new_module, new_module, stat);
    add_new_module_from_text(new_module_name, t, fortran_module_p(get_current_module_entity()), compilation_unit_of_module(get_current_module_name()) );
 
    free_text(t);
 
    return new_module;
}

References add_new_module_from_text(), add_parameter_variable_to_module(), add_private_variable_to_module(), compilation_unit_of_module(), FOREACH, fortran_module_p(), free_text(), gen_length(), get_current_module_entity(), get_current_module_name(), ifdebug, make_empty_subroutine(), make_language_unknown(), pips_debug, print_statement(), ref, REFERENCE, references_for_regions(), and text_named_module().

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

Creates a variable declared as a parameter in specified module.

This entity does not exist, we can safely create it

Definition at line 551 of file phrase_distributor.c.

{
  entity new_variable;
 
  if ((gen_find_tabulated(concatenate(new_module_name, 
                                      MODULE_SEP_STRING, 
                                      new_name, 
                                      NULL),
                          entity_domain)) == entity_undefined) 
    { 
      /* This entity does not exist, we can safely create it */
      
      new_variable = make_entity (strdup(concatenate(new_module_name, 
                                                     MODULE_SEP_STRING, 
                                                     new_name, NULL)),
                                  copy_type (entity_type(a_variable)),
                                  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()

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

Creates a private variable in specified module.

This entity does not exist, we can safely create it

Parameters

a_variable	_variable
new_name	ew_name
new_module_name	ew_module_name
module	odule

Definition at line 586 of file phrase_distributor.c.

{
  entity new_variable;
  entity a;
  basic base;
  
  if ((gen_find_tabulated(concatenate(new_module_name, 
                                      MODULE_SEP_STRING, 
                                      new_name, 
                                      NULL),
                          entity_domain)) == entity_undefined) 
    { 
      /* This entity does not exist, we can safely create it */
      
      new_variable = make_entity (strdup(concatenate(new_module_name, 
                                                     MODULE_SEP_STRING, 
                                                     new_name, NULL)),
                                  copy_type (entity_type(a_variable)),
                                  storage_undefined,
                                  copy_value (entity_initial(a_variable)));
      a = FindEntity(new_module_name, DYNAMIC_AREA_LOCAL_NAME); 
      base = variable_basic(type_variable(entity_type(a_variable)));
      entity_storage(new_variable) = 
        make_storage(is_storage_ram,
                     make_ram(module, a,
                              (basic_tag(base)!=is_basic_overloaded)?
                              (add_variable_to_area(a, new_variable)):(0),
                              NIL));
      pips_debug(2, "Created new private variable: %s\n", entity_global_name(new_variable));
      return new_variable;
    }
  else 
    {
      pips_internal_error("Entity already exist: %s", new_name);
      return NULL;
    }
}

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

Main function for PHRASE_DISTRIBUTION: phrase distribution for main module module, with root statement stat.

Definition at line 478 of file phrase_distributor.c.

{
  list l_stats;
  hash_table ht_stats;
  hash_table ht_params;
  hash_table ht_private;
  hash_table ht_in_regions;
  hash_table ht_out_regions;
 
  l_stats = identify_analyzed_statements_to_distribute (module_stat);
 
  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);
}

References compute_distribution_context(), distribute_code(), hash_get(), HASH_MAP, hash_table_free(), identify_analyzed_statements_to_distribute(), and module.

Referenced by phrase_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

This function is called after identification and isolation of a portion of code to externalize.

Externalization of specified code is done here.

Definition at line 398 of file phrase_distributor.c.

{
  entity new_module;
  statement call_statement;
  list call_params;
  string call_comments;
 
  new_module 
    = create_module_with_statement (externalized_code, 
                                    function_name,
                                    l_params,
                                    l_priv);
  
  call_params = NIL;
  MAP (REFERENCE, ref, {
    call_params = CONS(EXPRESSION, entity_to_expression(reference_variable(ref)), call_params);
  }, references_for_regions(l_params));
  
  // Insert an analyzed tag 
  {
    asprintf (&call_comments, 
             (concatenate("! ",
                                EXTERNALIZED_CODE_PRAGMA_CALL,
                                "\n",
                                NULL)),
             function_name);
  }
 
  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());
 
  ifdebug(5) {
    pips_debug(5, "BEFORE REPLACING\n");
    pips_debug(5, "externalized_code=\n");
    print_statement(externalized_code);
    pips_debug(5, "call_statement=\n");
    print_statement(call_statement);
    pips_debug(5, "module_stat=\n");
    print_statement(module_stat);
  }
 
  replace_in_sequence_statement_with(externalized_code,
                                     call_statement,
                                     module_stat);
 
  ifdebug(5) {
    pips_debug(5, "AFTER REPLACING\n");
    pips_debug(5, "externalized_code=\n");
    print_statement(externalized_code);
    pips_debug(5, "call_statement=\n");
    print_statement(call_statement);
    pips_debug(5, "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(5, "Code distribution for : [%s] is DONE\n", function_name);
}

References asprintf, concatenate(), CONS, create_module_with_statement(), entity_empty_label(), entity_to_expression(), EXPRESSION, EXTERNALIZED_CODE_PRAGMA_CALL, gen_consistent_p(), ifdebug, is_instruction_call, make_call(), make_instruction(), make_statement(), make_synchronization_none(), 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, and statement_ordering.

Referenced by distribute().

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

Definition at line 526 of file phrase_distributor.c.

{
  char *buffer;
  asprintf(&buffer,
          EXTERNALIZED_FUNCTION_PARAM_NAME,
          entity_local_name(variable),
          param_nb);
  return (buffer);
}

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

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

Definition at line 539 of file phrase_distributor.c.

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

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

Referenced by add_private_variable_to_module().

Here is the call graph for this function:

Here is the caller graph for this function:

get_function_name_by_searching_tag()

string get_function_name_by_searching_tag	(	statement	stat,
		const char *	tag
	)

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

phrase_distributor.c

Parameters

stat	tat
tag	ag

Definition at line 82 of file phrase_distributor.c.

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

References gen_nth(), ifdebug, 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 get_externalizable_function_name(), and get_externalized_function_name().

Here is the call graph for this function:

Here is the caller graph for this function:

identify_analyzed_statements_to_distribute()

list identify_analyzed_statements_to_distribute

(

statement

stat

)

This function return a list of statements that were previously marked for externalization during phase PHRASE_DISTRIBUTOR_INIT.

We identify all the statement containing an analyzed tag

Parameters

stat

tat

Definition at line 288 of file phrase_distributor.c.

{
  /* We identify all the statement containing an analyzed tag */
  return get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_ANALYZED,
                                                 stat); 
  
}

References EXTERNALIZED_CODE_PRAGMA_ANALYZED, and get_statements_with_comments_containing().

Referenced by comEngine_distribute(), and distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

identify_statements_to_distribute()

static list identify_statements_to_distribute ( statement  module_stat )

static

This function return a list of statements that are marked for externalization.

A well-formed externalizable code must be one or more continuous statements defined in a sequence statement framed with comments containing tags EXTERNALIZED_CODE_PRAGMA_BEGIN and EXTERNALIZED_CODE_PRAGMA_END

We identify all the statement containing a begin tag

We restructure the code to avoid imbricated sequences only if some portions are found (to allow more than one INIT)

We identify again (after code restructuration) all the statement containing a begin tag

We check that all those statements are contained in a sequence

Definition at line 304 of file phrase_distributor.c.

{
  list statements_containing_begin_tag = NIL;
  list statements_contained_in_a_sequence = NIL;
  list statements_to_distribute = NIL;
  
  /* We identify all the statement containing a begin tag */
  statements_containing_begin_tag 
    = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_BEGIN,
                                              module_stat); 
  /* We restructure the code to avoid imbricated sequences only if
   * some portions are found (to allow more than one INIT) */
  if (gen_length(statements_containing_begin_tag) > 0) {
    simple_restructure_statement(module_stat);
  }
 
  /* We identify again (after code restructuration) all the statement
   * containing a begin tag */
  statements_containing_begin_tag = NIL;
  statements_containing_begin_tag
    = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_BEGIN,
                                              module_stat);
 
  /* We check that all those statements are contained in a sequence */
  MAP (STATEMENT, s, {
    ifdebug(5) {
      pips_debug(5, "Potential externalizable statement:\n");
      print_statement(s);
    }
    if (statement_is_contained_in_a_sequence_p (module_stat,s)) {
      statements_contained_in_a_sequence
        = CONS (STATEMENT,
                s,
                statements_contained_in_a_sequence);
    }
    else {
      pips_user_warning("Malformed externalized code portion identified. Ignored.\n");
    }
  }, statements_containing_begin_tag);
 
  /* */
  FOREACH (STATEMENT, s, statements_contained_in_a_sequence){
      statement sequence_statement;
      string function_name;
      string end_tag;
      list potential_end_statement = NIL;
      sequence_statement = sequence_statement_containing (module_stat,s);
      ifdebug(5) {
          pips_debug(5, "Potential externalizable statement contained in a sequence \n");
          print_statement(s);
      }
      function_name = get_externalizable_function_name(s);
      if (function_name != NULL) {
          pips_debug(5, "Name: [%s] \n", function_name);
          asprintf (&end_tag, EXTERNALIZED_CODE_PRAGMA_END,function_name);
          potential_end_statement
              = get_statements_with_comments_containing (end_tag,
                      sequence_statement);
          if (gen_length(potential_end_statement) == 1) {
              statement begin_tag_statement = s;
              statement end_tag_statement 
                  = STATEMENT(gen_nth(0,potential_end_statement));
              statement container_of_end_tag_statement
                  = sequence_statement_containing (sequence_statement, end_tag_statement);
              if (container_of_end_tag_statement == sequence_statement) {
                  statement externalized_code
                      = isolate_code_portion (begin_tag_statement, 
                              end_tag_statement, 
                              sequence_statement);
                  statements_to_distribute 
                      = CONS (STATEMENT,
                              externalized_code,
                              statements_to_distribute);
              }
              else {
                  pips_user_warning("Malformed externalized code portion identified [%s]. End tag found at a bad place!!!. Ignored.\n", function_name);
              }
          }
          else {
              pips_user_warning("Malformed externalized code portion identified [%s]. %d end tags found!!!. Ignored.\n", function_name, gen_length(potential_end_statement));
          }
      }
      else {
          pips_user_warning("Malformed externalized code portion identified [Unnamed]!!!. Ignored.\n");
      }
  }
 
  return statements_to_distribute;
}

References asprintf, CONS, EXTERNALIZED_CODE_PRAGMA_BEGIN, EXTERNALIZED_CODE_PRAGMA_END, FOREACH, gen_length(), gen_nth(), get_externalizable_function_name(), get_statements_with_comments_containing(), ifdebug, isolate_code_portion(), MAP, NIL, pips_debug, pips_user_warning, print_statement(), sequence_statement_containing(), simple_restructure_statement(), STATEMENT, and statement_is_contained_in_a_sequence_p().

Referenced by prepare_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_code_portion()

static statement isolate_code_portion ( statement  begin_tag_statement, statement  end_tag_statement, statement  sequence_statement  )

static

At this point, we have a sequence statement sequence_statement which contains a statement with a begin tag and a statement with a end tag.

The goal is to transform this statement in a sequence statement with a single statement, which is the embedded statement that will be distributed. This function returns this isolated statement

First, count the number of statements to isolate in a single statement

Insert an analyzed tag

Build new isolated sequence statement

Build new sequence containing isolated sequence statement

Rebuild the sequence in the GOOD order

Nothing to do, the code is already isolated !

Definition at line 161 of file phrase_distributor.c.

{
  instruction i = statement_instruction(sequence_statement);
  list seq_stats = sequence_statements(instruction_sequence(i));
  list new_seq_stats = NIL;
  list isolated_seq_stats = NIL;
  bool statement_to_isolate;
  int nb_of_statements_to_isolate;
  string function_name = get_externalizable_function_name(begin_tag_statement);
 
 
  pips_assert ("sequence_statement is a sequence",
               instruction_tag(i) == is_instruction_sequence);
 
  pips_assert ("function_name is not NULL",
               function_name != NULL);
 
  /* First, count the number of statements to isolate in a single statement */
  statement_to_isolate = false;
  nb_of_statements_to_isolate = 0;
  MAP (STATEMENT, s, {
 
    if ((statement_to_isolate && (s != end_tag_statement))
        || ((!statement_to_isolate) && (s == begin_tag_statement))) {
      nb_of_statements_to_isolate++;
      isolated_seq_stats = CONS(STATEMENT, s, isolated_seq_stats);
    }
    if (statement_to_isolate && (s == end_tag_statement)) {
      statement_to_isolate = false;
    }
    if ((!statement_to_isolate) && (s == begin_tag_statement)) {
      statement_to_isolate = true;
    }
    
  }, seq_stats);
 
  remove_begin_tag (begin_tag_statement, function_name);
  remove_end_tag (end_tag_statement, function_name);
 
  /* Insert an analyzed tag */
  {
    char* new_tag ;
    asprintf (&new_tag, 
             (concatenate("! ",
                                EXTERNALIZED_CODE_PRAGMA_ANALYZED,
                                "\n",
                                NULL)),
             function_name,
             nb_of_statements_to_isolate);
    insert_comments_to_statement(begin_tag_statement, new_tag);
  }
 
  pips_debug(5, "Found %d statement to isolate\n",
             nb_of_statements_to_isolate);      
 
  if (nb_of_statements_to_isolate > 1) {
 
    /* Build new isolated sequence statement */
    
    sequence new_sequence = make_sequence (gen_nreverse(isolated_seq_stats));
    instruction sequence_instruction
      = make_instruction(is_instruction_sequence,
                         new_sequence);
    statement returned_statement 
      = make_statement(entity_empty_label(),
                       statement_number(sequence_statement),
                       statement_ordering(sequence_statement),
                       empty_comments,
                       sequence_instruction,NIL,NULL,
                       statement_extensions(sequence_statement), make_synchronization_none());
 
    bool isolated_seq_stats_is_inserted = false;
    
    /* Build new sequence containing isolated sequence statement */
 
    MAP (STATEMENT, s, {
      if ((statement_to_isolate && (s != end_tag_statement))
          || ((!statement_to_isolate) && (s == begin_tag_statement))) {
        if (!isolated_seq_stats_is_inserted) {
          new_seq_stats = CONS(STATEMENT, returned_statement, new_seq_stats);
          isolated_seq_stats_is_inserted = true;
        }
      }
      else {
        new_seq_stats = CONS(STATEMENT, s, new_seq_stats);
      }
      if (statement_to_isolate && (s == end_tag_statement)) {
        statement_to_isolate = false;
      }
      if ((!statement_to_isolate) && (s == begin_tag_statement)) {
        statement_to_isolate = true;
      }
    }, seq_stats); 
 
    /* Rebuild the sequence in the GOOD order */
    sequence_statements(instruction_sequence(i)) 
      = gen_nreverse(new_seq_stats);
 
    ifdebug(5) {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(returned_statement);
    }
 
    return returned_statement;
  }
  else if (nb_of_statements_to_isolate == 1) {
    /* Nothing to do, the code is already isolated ! */
    ifdebug(5) {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(begin_tag_statement);
    }
    return begin_tag_statement;
  }
  else {
    pips_user_warning("Malformed externalized code portion identified. No operation to do. Ignored.\n");
    return NULL;
  }
 
}

References asprintf, concatenate(), CONS, empty_comments, entity_empty_label(), EXTERNALIZED_CODE_PRAGMA_ANALYZED, gen_nreverse(), get_externalizable_function_name(), ifdebug, insert_comments_to_statement(), instruction_sequence, instruction_tag, is_instruction_sequence, make_instruction(), make_sequence(), make_statement(), make_synchronization_none(), MAP, NIL, pips_assert, pips_debug, pips_user_warning, print_statement(), remove_begin_tag(), remove_end_tag(), sequence_statements, STATEMENT, statement_extensions, statement_instruction, statement_number, and statement_ordering.

Referenced by identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

phrase_distributor()

bool phrase_distributor

(

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

Reorder the module, because new statements have been added

update/release resources

Parameters

module_name

odule_name

Definition at line 816 of file phrase_distributor.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\n");
  distribute (module_stat, module);
  pips_debug(2, "END of PHRASE_DISTRIBUTOR\n");
 
  //print_statement(module_stat);
 
  pips_assert("Statement structure is consistent after PHRASE_DISTRIBUTOR", 
              gen_consistent_p((gen_chunk*)module_stat));
              
  pips_assert("Statement is consistent after PHRASE_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, 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:

phrase_distributor_init()

bool phrase_distributor_init

(

const char *

module_name

)

get the resources

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

module_name

odule_name

Definition at line 768 of file phrase_distributor.c.

{
  
  /* get the resources */
  statement stat = (statement) db_get_memory_resource(DBR_CODE, 
                                                      module_name, 
                                                      true);
  
  
  set_current_module_statement(stat);
  set_current_module_entity(module_name_to_entity(module_name)); //FI: redundant
  
  debug_on("PHRASE_DISTRIBUTOR_DEBUG_LEVEL");
 
  /* Now do the job */
 
  pips_debug(2, "BEGIN of PHRASE_DISTRIBUTOR_INIT\n");
  prepare_distribute (stat);
  pips_debug(2, "END of PHRASE_DISTRIBUTOR_INIT\n");
 
  pips_assert("Statement structure is consistent after PHRASE_DISTRIBUTOR_INIT", 
              gen_consistent_p((gen_chunk*)stat));
              
  pips_assert("Statement is consistent after PHRASE_DISTRIBUTOR_INIT", 
               statement_consistent_p(stat));
 
  
  /* Reorder the module, because new statements have been added */  
  module_reorder(stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, 
                         compute_callees(stat));
  
  /* update/release resources */
  reset_current_module_statement();
  reset_current_module_entity();
  
  debug_off();
  
  return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_consistent_p(), module_name(), module_name_to_entity(), module_reorder(), pips_assert, pips_debug, prepare_distribute(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_consistent_p().

Here is the call graph for this function:

prepare_distribute()

static void prepare_distribute ( statement  module_stat )

static

Main function for PHRASE_DISTRIBUTION_INIT: phrase distribution for module module_stat.

Definition at line 518 of file phrase_distributor.c.

{
  identify_statements_to_distribute (module_stat);
}

References identify_statements_to_distribute().

Referenced by phrase_distributor_init().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_begin_tag()

static void remove_begin_tag ( statement  stat, string  function_name  )

static

Remove begin tag for statement stat and function function_name.

Definition at line 127 of file phrase_distributor.c.

{
  char* removed_tag ;
  asprintf (&removed_tag,EXTERNALIZED_CODE_PRAGMA_BEGIN,function_name);
  ifdebug(2) {
    pips_debug(2, "REMOVE %s from\n", removed_tag);
    print_statement (stat);
  }
  clean_statement_from_tags (removed_tag, stat);
}

References asprintf, clean_statement_from_tags(), EXTERNALIZED_CODE_PRAGMA_BEGIN, ifdebug, pips_debug, and print_statement().

Referenced by isolate_code_portion().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_end_tag()

static void remove_end_tag ( statement  stat, string  function_name  )

static

Remove end tag for statement stat and function function_name.

Definition at line 141 of file phrase_distributor.c.

{
  char* removed_tag ;
  asprintf (&removed_tag,EXTERNALIZED_CODE_PRAGMA_END,function_name);
  ifdebug(2) {
    pips_debug(2, "REMOVE %s from\n", removed_tag);
    print_statement (stat);
  }
  clean_statement_from_tags (removed_tag, stat);
}

References asprintf, clean_statement_from_tags(), EXTERNALIZED_CODE_PRAGMA_END, ifdebug, pips_debug, and print_statement().

Referenced by isolate_code_portion().

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 814 of file phrase_distributor.c.

Referenced by GenericAddLocalEntityToDeclarations(), make_new_entity(), make_nlc_entity(), make_nsp_entity(), make_nub_entity(), phrase_comEngine_distributor(), phrase_distributor(), replace_indices_region(), and replace_indices_region_com().