phrase.h File Reference

#include "dg.h"
#include "graph.h"

Include dependency graph for phrase.h:

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

Go to the source code of this file.

Macros
#define	__PHRASEC_LOCAL_H__
	Warning! Do not modify this file that is automatically generated! More...

Typedefs
typedef dg_arc_label	arc_label
typedef dg_vertex_label	vertex_label

Functions
statement	comEngine_opt_loop_interchange (statement, statement, entity)
expression	get_fifoExp_from_ref (reference, expression, hash_table)
	comEngine_HRE_distribute.c More...
statement	generate_fifo_stat2 (reference, bool)
statement	generate_ind_fifo_stat2 (entity, entity, bool)
void	generate_fifo_stats2 (list, list *, list *)
statement	HRE_distribute (statement, string, const char *)
entity	comEngine_make_new_scalar_variable (const char *, basic)
statement	make_toggle_init_statement (entity)
statement	make_toggle_inc_statement (entity, int)
statement	generate_code_function (statement, bool)
statement	comEngine_generate_code (statement)
bool	phrase_remove_dependences (const char *)
	phrase_remove_dependences.c More...
expression	get_fifo_from_ref (reference)
entity	get_HRE_buff_ent_from_ref (reference)
statement	make_wait_step_statement (void)
void	replace_array_ref_with_fifos (list, expression, entity, statement *)
statement	generate_stat_from_ref_list_HRE (list, statement)
list	generate_stat_from_ref_list_HRE_list (list, list)
void	get_supportedRef_HRE (statement, list *, list *)
void	process_replacement_HRE (list, expression, statement *)
list	process_replacement_HRE_OutRef (list, list)
statement	get_call_stat_HRE (statement)
list	make_loop_lStats_HRE (statement, entity, statement, entity, list, hash_table, expression)
statement	generate_code_test_HRE (statement)
list	process_gLoopToSync_HRE (statement, list)
statement	comEngine_generate_HRECode (statement, string, list, list, list, list, const char *, int)
bool	has_call_stat_inside (statement)
	comEngine_generate_procCode.c More...
statement	make_step_inc_statement (int)
statement	make_loop_step_stat (statement, entity)
statement	make_toggle_mmcd (entity)
statement	make_init_newInd_stat (statement, entity)
statement	make_transStat (statement, entity, entity, expression)
void	comEngine_replace_reference_in_stat (statement, reference, expression)
statement	make_exec_mmcd (void)
statement	generate_stat_from_ref_list_proc (list, list, statement)
list	generate_stat_from_ref_list_proc_list (list, list)
void	process_innerStat1_proc (statement, entity, entity, entity)
void	get_supportedRef_proc (statement, hash_table, list *, list *)
statement	get_call_stat_proc (statement)
list	make_loop_lStats_proc (statement, entity, statement, entity, list, hash_table, expression)
list	add_index_out_effect_proc (loop, list)
statement	generate_code_test_proc (statement)
list	process_gLoopToSync_proc (statement, list)
void	create_realFifo_proc (statement, list)
statement	comEngine_generate_procCode (statement, list, list)
list	comEngine_expression_to_reference_list (expression, list)
	comEngine_feasability.c More...
bool	code_has_write_eff_ref_p (reference, statement)
list	reference_indices_entity_list (reference)
bool	comEngine_feasability (statement, graph)
void	create_HRE_module (const char *, const char *, statement, entity)
void	comEngine_distribute (const char *, statement, entity)
bool	phrase_comEngine_distributor (const char *)
string	get_function_name_by_searching_tag (statement, const char *)
	phrase_distributor.c More...
list	identify_analyzed_statements_to_distribute (statement)
	This function return a list of statements that were previously marked for externalization during phase PHRASE_DISTRIBUTOR_INIT. More...
entity	create_private_variable_for_new_module (entity, const char *, const char *, entity)
	Creates a private variable in specified module. More...
void	add_parameter_variable_to_module (reference, entity, statement, string, int)
	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, entity, statement, string)
	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 *)
bool	phrase_distributor (const char *)
entity	create_parameter_for_new_module (variable, const char *, const char *, entity, int)
	phrase_distributor_control_code.c More...
entity	create_integer_parameter_for_new_module (const char *, const char *, entity, int)
	Create new integer variable parameter for a newly created module. More...
void	store_new_module (const char *, entity, statement)
	Store (PIPDBM) newly created module module with module_statement as USER_FILE by saving pretty printing. More...
entity	create_new_common_variable (string, entity, entity, variable)
	Creates and declares a new variable for a newly created common. More...
entity	create_new_scalar_common_variable (string, entity, entity, basic)
	Creates and declares a new scalar variable for a newly created common. More...
entity	create_new_integer_scalar_common_variable (string, entity, entity)
	Creates and declares a new integer scalar variable for a newly created common. More...
void	declare_common_variables_in_module (entity, entity)
	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)
string	get_in_param_id_name (entity variable, entity)
string	get_out_param_id_name (entity variable, entity)
string	get_function_id_name (entity)
string	get_common_param_name (entity variable, entity)
string	get_send_parameter_module_name (variable)
string	get_receive_parameter_module_name (variable)
entity	entity_in_module (const char *, entity)
	Return entity named name in specified module. More...
bool	phrase_distributor_control_code (const char *)
entity	make_start_ru_module (hash_table, statement *, int, entity, list)
	phrase_distributor_communication.c More...
entity	make_wait_ru_module (statement *, int, entity, list)
string	get_dynamic_variable_name (entity)
	Return DYN_VAR_PARAM_NAME name for a dynamic variable. More...
string	get_ref_var_param_name (entity)
	Return REF_VAR_PARAM_NAME name for a dynamic variable. More...
string	get_send_param_module_name (entity, effect)
string	get_receive_param_module_name (entity, effect)
list	make_send_scalar_params_modules (hash_table, int, entity, list)
	Build and return list of modules used for INPUT communications (SEND_PARAMETERS...) More...
list	make_receive_scalar_params_modules (hash_table, int, entity, list)
	Build and return list of modules used for OUTPUT communications (RECEIVE_PARAMETERS...) More...
void	compute_region_variables (effect, list *, list *)
entity	create_private_integer_variable_for_new_module (string, const char *, entity)
	Creates an integer variable in specified module. More...
list	make_send_array_params_modules (entity, list, entity, entity, int)
	Make all SEND_PARAM communication modules for non-scalar regions for a given function. More...
list	make_receive_array_params_modules (entity, list, entity, entity, int)
	Make all RECEIVE_PARAM communication modules for non-scalar regions for a given function. More...
bool	compute_distribution_context (list, statement, entity, hash_table *, hash_table *, hash_table *, hash_table *, hash_table *)
	distribution_context.c More...
bool	compute_distribution_controlization_context (list, statement, entity, hash_table *, hash_table *, hash_table *, hash_table *, hash_table *)
	This function is called during PHRASE distribution controlization. More...
list	compute_regions_union (list, list)
	Compute union of exact regions. More...
bool	internal_compute_distribution_context (statement, hash_table *, hash_table *, hash_table *, hash_table *, void *)
	Internally used to compute distribution context for statement externalized_code. More...
string	get_externalizable_function_name (statement)
	Return the identified function name of the externalized portion of code by searching comment matching tag EXTERNALIZED_CODE_PRAGMA_BEGIN. More...
string	get_externalized_function_name (statement)
	Return the identified function name of the externalized portion of code by searching comment matching tag EXTERNALIZED_CODE_PRAGMA_CALL. More...
string	get_externalized_and_analyzed_function_name (statement, int *)
	Return the identified function name of the externalized portion of code by searching comment matching tags EXTERNALIZED_CODE_PRAGMA_ANALYZED Sets the number of statements of this externalizable statement. More...
string	variable_to_string (variable)
	Return a unique (regarding variable_equal_p(var1,var2)) string representation of a variable var. More...
void	register_scalar_communications (hash_table *, entity, list)
	Build an HASHTABLE where keys are VARIABLE and values are HASHTABLE where keys are modules or externalized function (ENTITY) and values are list of regions. More...
bool	fsm_generation (const char *)
	fsm_generation.c More...
bool	print_code_smalltalk (const char *)
	print_code_smalltalk.c More...
bool	fsm_merge_states (const char *)
	fsm_merge_states.c More...
bool	fsm_split_state (const char *)
	fsm_split_state.c More...
bool	full_fsm_generation (const char *)
	full_fsm_generation.c More...
statement	spaghettify_loop (statement, const char *)
	loop_spaghettify.c More...
statement	spaghettify_whileloop (statement, const char *)
	whileloop_spaghettify.c More...
statement	spaghettify_forloop (statement, const char *)
	forloop_spaghettify.c More...
statement	spaghettify_test (statement, const char *)
	test_spaghettify.c More...
statement	spaghettify_statement (statement, const char *)
	spaghettify.c More...
bool	spaghettify (const char *)
bool	full_spaghettify (const char *)
	full_spaghettify.c More...
expression	make_expression_with_state_variable (entity, int value, string)
	fsm_tools.c More...
entity	create_state_variable (const char *, int)
	This function creates (and add declaration) state variable. More...
statement	make_state_variable_assignement_statement (statement, entity, int)
	This function build and return a statement representing the initial assigment of the state_variable, given the UNSTRUCTURED statement stat. More...
int	entry_state_variable_value_for_unstructured (statement)
	Return the state variable value corresponding to the entry in a unstructured statement. More...
int	exit_state_variable_value_for_unstructured (statement)
	Return the state variable value corresponding to the exit in a unstructured statement NB: always return 0. More...
statement	make_reset_state_variable_statement (statement, entity)
	This function build and return a statement representing the initial assigment of the state_variable, given the UNSTRUCTURED statement stat. More...
statement	make_transition_statement (control, statement, entity, const char *)
	This function build a transition statement (a TEST statement) corresponding to the current control current_node and the root_statement root_statement. More...
statement	make_fsm_transitions_statement (statement, entity, const char *)
	This function build and return a statement representing the transitions computation in the FSM, given the UNSTRUCTURED statement stat. More...
statement	make_fsm_from_statement (statement, entity, const char *)
	This function build and return a statement representing the FSM code equivalent to the given unstructured statement stat. More...
statement	fsmize_statement (statement, entity, const char *)
	This function is recursively called during FSMization. More...
string	statement_type_as_string (statement)
	phrase_tools.c More...
void	debug_statement (const char *, statement, int)
	DEBUG FUNCTION: print debugging informations for a statement stat. More...
void	debug_control (const char *, control, int)
	DEBUG FUNCTION: print debugging informations for a control a_control. More...
void	debug_unstructured (unstructured, int)
	DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured. More...
void	short_debug_unstructured (unstructured, int)
	DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured (short version) More...
entity	clone_variable_with_new_name (entity, const char *, const char *)
	This function build and return new variable from a variable a_variable, with name new_name. More...
entity	make_variable_from_name_and_entity (entity, const char *, statement, const char *)
	Build and return new entity obtained by cloning variable cloned_variable, with a name obtained by the concatenation of base_name and the statement ordering of statement stat. More...
statement	make_binary_call_statement (const char *, expression, expression, statement)
	Build and return new statement which is a binary call with the 2 expressions expression1 and expression2, with empty label, statement number and ordering of statement stat, and empty comments. More...
statement	make_assignement_statement (entity, expression, statement)
	Build and return new statement which is a assignement of variable a_variable with expression an_expression, with empty label, statement number and ordering of statement stat, and empty comments. More...
int	beautify_ordering (int)
	Special function made for Ronan Keryell who likes a lot when a integer number is coded on 3 bits :-) More...
void	clean_statement_from_tags (const char *, statement)
list	get_statements_with_comments_containing (const char *, statement)
bool	statement_is_contained_in_a_sequence_p (statement, statement)
statement	sequence_statement_containing (statement, statement)
void	replace_in_sequence_statement_with (statement, statement, statement)
	Replace statement old_stat by statement new_stat, asserting that this statement is contained in a sequence. More...
list	references_for_regions (list)
	Return a list of references corresponding to a list of regions. More...

Variables
hash_table	gLoopToOpt
	cproto-generated files More...
hash_table	gLoopToOuterInd
	comEngine_generate_code.c More...
bool	gGenHRE
list	glToggleInitStats
hash_table	gRefToHREVar
	comEngine_generate_HRECode.c More...
hash_table	gLoopToRef
	comEngine_distribute.c More...
hash_table	gStatToRef
hash_table	gRefToEff
hash_table	gLoopToSync
hash_table	gLoopToSupRef
hash_table	gLoopToUnSupRef
entity	gHREMemory
expression	gBufferSizeEnt
int	gBufferSize
hash_table	gRefToFifo
hash_table	gRefToFifoOff
hash_table	gRefToHREFifo
hash_table	gStatToHtOffset
hash_table	gRefToBuffSize
hash_table	gIndToNum
hash_table	gRefToInd
hash_table	gLoopToToggleEnt
hash_table	gEntToHREFifo
hash_table	gRefToToggle
hash_table	gToggleToInc
hash_table	gIsNewLoop

Macro Definition Documentation

__PHRASEC_LOCAL_H__

#define __PHRASEC_LOCAL_H__

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/phrase/phrase-local.h instead, to add your own modifications. header file built by cproto phrase-local.h

Definition at line 34 of file phrase.h.

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Definition at line 37 of file phrase.h.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 38 of file phrase.h.

Function Documentation

add_index_out_effect_proc()

list add_index_out_effect_proc	(	loop	curLoop,
		list	lStats
	)

Parameters

curLoop	urLoop
lStats	Stats

Definition at line 1129 of file comEngine_generate_procCode.c.

{
  statement assignStat =
    make_assign_statement(entity_to_expression(loop_index(curLoop)),
                          copy_expression(range_upper(loop_range(curLoop))));
 
  return gen_nconc(lStats, CONS(STATEMENT, assignStat, NIL));
}

References CONS, copy_expression(), entity_to_expression(), gen_nconc(), loop_index, loop_range, make_assign_statement(), NIL, range_upper, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

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

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:

beautify_ordering()

int beautify_ordering

(

int

an_ordering

)

Special function made for Ronan Keryell who likes a lot when a integer number is coded on 3 bits :-)

Parameters

an_ordering

n_ordering

Definition at line 407 of file phrase_tools.c.

{
  int ordering_up = (an_ordering & 0xffff0000) >> 16;
  int ordering_down = (an_ordering & 0x0000ffff);
  return ordering_up + ((ordering_down-1) << 16);
}

Referenced by entry_state_variable_value_for_unstructured(), and make_transition_statement().

Here is the caller graph for this function:

clean_statement_from_tags()

void clean_statement_from_tags	(	const char *	comment_portion,
		statement	stat
	)

Parameters

comment_portion	omment_portion
stat	tat

Definition at line 414 of file phrase_tools.c.

{
  string comments;
  char*  next_line;
  string searched_string;
 
  if (!statement_with_empty_comment_p(stat)) {
 
    string new_comments = NULL;
 
    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 {
        if (strstr(next_line,searched_string) == NULL) {
          if (new_comments != NULL) {
            new_comments = strdup(concatenate(new_comments, next_line, "\n", NULL));
          }
          else {
            new_comments = strdup(concatenate("", next_line, "\n", NULL));
          }
        }
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
   
    if (new_comments != NULL) {
      statement_comments(stat) = new_comments;
    }
    else {
      statement_comments(stat) = empty_comments;
    }
  }
   
}

References concatenate(), empty_comments, statement_comments, statement_with_empty_comment_p(), and strdup().

Referenced by remove_begin_tag(), and remove_end_tag().

Here is the call graph for this function:

Here is the caller graph for this function:

clone_variable_with_new_name()

entity clone_variable_with_new_name	(	entity	a_variable,
		const char *	new_name,
		const char *	module_name
	)

This function build and return new variable from a variable a_variable, with name new_name.

If an entity called new_name already exists, return NULL. New variable is added to declarations

Assert that module represent a value code

This entity does not exist, we can safely create it

new_variable = copy_entity (a_variable); entity_name(new_variable) = strdup(concatenate(module_name, MODULE_SEP_STRING, new_name, NULL));

ew_variable = find_or_create_scalar_entity (strdup(concatenate(module_name, MODULE_SEP_STRING, new_name, NULL)),module_name, is_basic_int);

This entity already exist, we return null

Parameters

a_variable	_variable
new_name	ew_name
module_name	odule_name

Definition at line 269 of file phrase_tools.c.

{
  entity module;
  entity new_variable;
 
  module = module_name_to_entity(module_name);
  /* Assert that module represent a value code */
  pips_assert("it is a code", value_code_p(entity_initial(module)));
 
  if ((gen_find_tabulated(concatenate(module_name,
                                      MODULE_SEP_STRING,
                                      new_name,
                                      NULL),
                          entity_domain)) == entity_undefined)
    {
      /* This entity does not exist, we can safely create it */
     
      /* new_variable = copy_entity (a_variable);
         entity_name(new_variable) 
         = strdup(concatenate(module_name,
         MODULE_SEP_STRING,
         new_name, NULL)); */
     
      new_variable = make_entity (strdup(concatenate(module_name,
                                                     MODULE_SEP_STRING,
                                                     new_name, NULL)),
                                  copy_type (entity_type(a_variable)),
                                  copy_storage (entity_storage(a_variable)),
                                  copy_value (entity_initial(a_variable)));
     
      /*new_variable
        = find_or_create_scalar_entity (strdup(concatenate(module_name,
        MODULE_SEP_STRING,
        new_name, NULL)),module_name,
        is_basic_int);*/
     
      AddEntityToDeclarations(new_variable,module);
      return new_variable;
    }
  else
    {
      /* This entity already exist, we return null */
      return NULL;
    }
}

code_has_write_eff_ref_p()

bool code_has_write_eff_ref_p	(	reference	ref,
		statement	stat
	)

Parameters

ref	ef
stat	tat

Definition at line 563 of file comEngine_feasability.c.

{
   bool actionWrite = false;
 
   MAP(EFFECT, f, 
   {
      bool effEntIsIndex = false;
      entity effEnt = effect_entity(f);
 
      MAP(STATEMENT,loopStat,
      {
        entity index = loop_index(statement_loop(loopStat));
 
        if(same_entity_p(index, effEnt))
          {
            effEntIsIndex = true;
          }
 
      }, lLoop);
 
      if(effEntIsIndex)
        {
          continue;
        }
 
      if(action_write_p(effect_action(f)) && 
         same_entity_p(reference_variable(ref), effEnt))
        {
          actionWrite = true;
        }
 
   }, load_cumulated_rw_effects_list(stat));
 
   return actionWrite;
}

References action_write_p, EFFECT, effect_action, effect_entity(), f(), lLoop, load_cumulated_rw_effects_list(), loop_index, MAP, ref, reference_variable, same_entity_p(), STATEMENT, and statement_loop().

Referenced by check_loop_distribution_feasability(), phrase_check_reference(), and process_ref_list().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_distribute()

void comEngine_distribute	(	const char *	module_name,
		statement	module_stat,
		entity	module
	)

Parameters

module_name	odule_name
module_stat	odule_stat
module	odule

Definition at line 469 of file comEngine_distribute.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;
 
  graph dg = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
  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, {
      comEngine_distribute_code (module_name,
                                 function_name,
                                 stat, 
                                 hash_get(ht_in_regions,function_name),
                                 hash_get(ht_out_regions,function_name),
                                 hash_get(ht_params,function_name),
                                 hash_get(ht_private,function_name),
                                 dg);
  },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 comEngine_distribute_code(), compute_distribution_context(), db_get_memory_resource(), dg, hash_get(), HASH_MAP, hash_table_free(), identify_analyzed_statements_to_distribute(), module, and module_name().

Referenced by phrase_comEngine_distributor().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_expression_to_reference_list()

list comEngine_expression_to_reference_list	(	expression	e,
		list	lr
	)

comEngine_feasability.c

comEngine_feasability.c

references to functions and constants (which are encoded as null-ary functions) are not recorded

Parameters

lr

r

Definition at line 100 of file comEngine_feasability.c.

{
    syntax s = expression_syntax(e);
    lr = local_syntax_to_reference_list(s, lr);
    return lr;
}

References expression_syntax, and local_syntax_to_reference_list().

Referenced by check_call_distribution_feasability(), check_test_distribution_feasability(), fill_gRefToEncLoop_call(), fill_gRefToEncLoop_test(), generate_code_call(), HRE_distribute_call(), HRE_distribute_test(), local_syntax_to_reference_list(), and reference_indices_entity_list().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_feasability()

bool comEngine_feasability	(	statement	externalized_code,
		graph	dg
	)

Parameters

externalized_code	xternalized_code
dg	g

Definition at line 1177 of file comEngine_feasability.c.

{
  bool success = false;
 
  // Initialize some global variables
  gDg = dg;
  g_externalized_code = externalized_code;
  gIfCount = 0;
  gRefToEncLoop = hash_table_make(hash_pointer, 0);
  lLoop = NIL;
  glIndUsed = NIL;
 
  hash_dont_warn_on_redefinition();
 
  // Fill the hash_table gRefToEncLoop
  fill_gRefToEncLoop(externalized_code);
 
  pips_assert("lLoop == NIL", lLoop == NIL);
 
  // Perform the actual analysis
  success = check_distribution_feasability(externalized_code);
 
  hash_warn_on_redefinition();
 
  // Free some global variables
  HASH_MAP(curRef, curLoopList,
  {
    gen_free_list(curLoopList);
  }, gRefToEncLoop);
  hash_table_free(gRefToEncLoop);
  gen_free_list(glIndUsed);
 
  return success;
}

References check_distribution_feasability(), dg, fill_gRefToEncLoop(), g_externalized_code, gDg, gen_free_list(), gIfCount, glIndUsed, gRefToEncLoop, hash_dont_warn_on_redefinition(), HASH_MAP, hash_pointer, hash_table_free(), hash_table_make(), hash_warn_on_redefinition(), lLoop, NIL, and pips_assert.

Referenced by comEngine_distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_generate_code()

statement comEngine_generate_code

(

statement

stat

)

Parameters

stat

tat

Definition at line 1187 of file comEngine_generate_code.c.

{
  statement newStat = statement_undefined;
 
  // Initialize some global variables
  COM_OPT = true;
  gExecPut = false;
  gLoopToOuterInd = hash_table_make(hash_pointer, 0);
  gHtCurNewInd = hash_table_make(hash_pointer, 0);
  glCurLoop = NIL;
  glCurRep = NIL;
  gLoopToOpt = hash_table_make(hash_pointer, 0);
  glOutEffStats = NIL;
  glToggleInitStats = NIL;
 
  // Do the job
  newStat = generate_code_function(stat, false);
 
  if(statement_block_p(stat))
    {
      newStat = process_code_seq(newStat, stat);
    }
 
  // Add the loop indices statements
  if(glOutEffStats != NIL)
    {
      newStat =
        make_block_statement(gen_nconc(CONS(STATEMENT, newStat, NIL),
                                       glOutEffStats));
    }
 
  // Add the toggle initialization statements
  if(glToggleInitStats != NIL)
    {
      newStat =
        make_block_statement(gen_nconc(glToggleInitStats,
                                       CONS(STATEMENT, newStat, NIL)));
    }
 
  // Free some global variables
  hash_table_free(gHtCurNewInd);
  hash_table_free(gLoopToOpt);
  hash_table_free(gLoopToOuterInd);
 
  return newStat;
}

References COM_OPT, CONS, gen_nconc(), generate_code_function(), gExecPut, gHtCurNewInd, glCurLoop, glCurRep, gLoopToOpt, gLoopToOuterInd, glOutEffStats, glToggleInitStats, hash_pointer, hash_table_free(), hash_table_make(), make_block_statement(), NIL, process_code_seq(), STATEMENT, statement_block_p, and statement_undefined.

Referenced by comEngine_generate_HRECode(), and comEngine_generate_procCode().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_generate_HRECode()

statement comEngine_generate_HRECode	(	statement	,
		string	,
		list	,
		list	,
		list	,
		list	,
		const char *	,
		int
	)

comEngine_generate_procCode()

statement comEngine_generate_procCode	(	statement	,
		list	,
		list
	)

comEngine_make_new_scalar_variable()

entity comEngine_make_new_scalar_variable	(	const char *	prefix,
		basic	bas
	)

Parameters

prefix	refix
bas	as

Definition at line 94 of file comEngine_generate_code.c.

{
  entity retEnt = entity_undefined;
  make_new_scalar_variable_with_prefix(prefix,
                                             get_current_module_entity(),
                                             bas);
  AddEntityToCurrentModule(retEnt);
 
  return retEnt;
}

References AddEntityToCurrentModule(), entity_undefined, get_current_module_entity(), make_new_scalar_variable_with_prefix(), and prefix.

Referenced by comEngine_generate_procCode(), fill_gLoopToToggleEnt(), generate_code_loop(), regenerate_toggles(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_opt_loop_interchange()

statement comEngine_opt_loop_interchange	(	statement	stat,
		statement	innerStat,
		entity	newInd
	)

Parameters

stat	tat
innerStat	nnerStat
newInd	ewInd

Definition at line 411 of file comEngine_optimization_function.c.

{
  printf("comEngine_opt_loop_interchange\n");
  print_statement(innerStat);
 
  pips_assert("innerStat is a loop statement", statement_loop_p(innerStat));
 
  statement body = loop_body(statement_loop(innerStat));
 
  if(!statement_block_p(body))
    {
      return innerStat;
    }
 
  printf("stat\n");
  print_statement(stat);
 
  bool allowedOpt = (intptr_t)hash_get(gLoopToOpt, stat);
 
  pips_assert("allowedOpt != HASH_UNDEFINED_VALUE",
              allowedOpt != (intptr_t)HASH_UNDEFINED_VALUE);
 
  if(!allowedOpt)
    {
      printf("opt not all\n");
      return innerStat;
    }
  else
    {
      printf("opt all\n");
    }
 
  glSeqs = NIL;
  glStats = NIL;
 
  opt_loop_interchange_fill_lists(body);
 
  if(glStats != NIL)
    {
          printf("put glSeqs 3\n");
          MAP(STATEMENT, curStat,
          {
            print_statement(curStat);
          }, glStats);
 
      glSeqs = gen_nconc(glSeqs, CONS(LIST, glStats, NIL));
 
      glStats = NIL;
    }
 
  list lStats = NIL;
  statement loopPattern = make_loopPattern(innerStat);
 
  //printf("glSeqs\n");
  MAP(LIST, curList,
  {
  /*
    //printf("glSeqs it 1\n");
    MAP(STATEMENT, curStat,
    {
      //printf("glSeqs it 2\n");
      //print_statement(curStat);
      //printf("glSeqs it 2 end\n");
 
    }, curList);
    */
 
    statement seqStat = make_seqStat(stat, loopPattern, curList, newInd);
 
    lStats = gen_nconc(lStats, CONS(STATEMENT, seqStat, NIL));
 
  }, glSeqs);
 
  gen_free_list(glSeqs);
 
  free_statement(loopPattern);
 
  printf("bef 2\n");
  loop_body(statement_loop(innerStat)) = statement_undefined;
  printf("aft 2\n");
 
  free_statement(innerStat);
 
  statement newStat = make_block_statement(lStats);
 
  printf("comEngine_opt_loop_interchange newStat\n");
  print_statement(newStat);
 
  return newStat;
}

References CONS, free_statement(), gen_free_list(), gen_nconc(), gLoopToOpt, glSeqs, glStats, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, LIST, loop_body, make_block_statement(), make_loopPattern(), make_seqStat(), MAP, NIL, opt_loop_interchange_fill_lists(), pips_assert, print_statement(), printf(), STATEMENT, statement_block_p, statement_loop(), statement_loop_p(), and statement_undefined.

Referenced by usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_replace_reference_in_stat()

void comEngine_replace_reference_in_stat	(	statement	stat,
		reference	ref,
		expression	new
	)

Parameters

stat	tat
ref	ef
new	ew

Definition at line 871 of file comEngine_generate_procCode.c.

{
  gRefToReplace = ref;
 
  gen_context_recurse(stat, new,
    expression_domain, gen_true2, comEngine_replace_reference_in_stat_rwt);
}

References comEngine_replace_reference_in_stat_rwt(), expression_domain, gen_context_recurse, gen_true2(), gRefToReplace, and ref.

Referenced by generate_code_loop(), make_lInitStats(), make_lSwitchStats(), make_mmcd_stats_from_ref(), process_innerStat1_proc(), regenerate_toggles(), replace_array_ref_with_fifos(), and replace_array_ref_with_fifos2().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_distribution_context()

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

distribution_context.c

distribution_context.c

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

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

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

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

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

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

Return true if everything is OK

NB: All lists are sorted using externalized fonction name

lazy init

lazy init

lazy init

lazy init

lazy init

Register new externalized function

Parameters

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

Definition at line 113 of file distribution_context.c.

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

compute_distribution_controlization_context()

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

This function is called during PHRASE distribution controlization.

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

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

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

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

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

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

Return true if everything is OK

NB: All lists are sorted using externalized fonction name

lazy init

lazy init

lazy init

lazy init

lazy init

Register new externalized function

This function has NOT been already defined, Register it

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

Check that IN and OUT regions match !

NOT IMPLEMENTED Yet !

Parameters

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

Definition at line 216 of file distribution_context.c.

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

compute_region_variables()

void compute_region_variables	(	effect	,
		list *	,
		list *
	)

Referenced by controlize_distribution().

Here is the caller graph for this function:

compute_regions_union()

list compute_regions_union	(	list	l_in,
		list	l_out
	)

Compute union of exact regions.

Parameters

l_in	_in
l_out	_out

Definition at line 291 of file distribution_context.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_HRE_module()

void create_HRE_module	(	const char *	new_module_name,
		const char *	module_name,
		statement	stat,
		entity	new_fun
	)

builds some kind of module / statement for the clone.

add some comments before the code.

give the clonee a user file.

Parameters

new_module_name	ew_module_name
module_name	odule_name
stat	tat
new_fun	ew_fun

Definition at line 283 of file comEngine_distribute.c.

{
  //printf("new HRE module\n");
  //print_statement(stat);
 
  reset_current_module_entity();
 
  set_current_module_entity(module_name_to_entity(module_name));
 
  entity cloned = get_current_module_entity();
  const char* name = entity_local_name(cloned);
  const char* new_name;
  string comments;
  //entity new_fun;
  //statement stat;
  bool saved_b1, saved_b2;
  text t;
    
  /* builds some kind of module / statement for the clone.
   */
  new_name = new_module_name;
  //new_fun = make_empty_subroutine(new_name);
 
  saved_b1 = get_bool_property(ALL_DECLS);
  saved_b2 = get_bool_property(STAT_ORDER);
  set_bool_property(ALL_DECLS, true);
  set_bool_property(STAT_ORDER, false);
 
  //stat = comEngine_generate_HRECode(externalized_code, new_fun, l_in, l_out);
 
  //add_variables_to_module(l_params, l_priv,
  //              new_fun, stat);
 
  move_declarations(new_fun, stat);
 
  reset_current_module_entity();
 
  set_current_module_entity(module_name_to_entity(module_name));
 
  t = text_named_module(new_fun, cloned, stat);
 
  set_bool_property(ALL_DECLS, saved_b1);
  set_bool_property(STAT_ORDER, saved_b2);
 
  /* add some comments before the code.
   */
  comments = strdup(concatenate(
                                "//\n"
                                "// PIPS: please caution!\n"
                                "//\n"
                                "// this routine has been generated as a clone of ", name, "\n"
                                "// the code may change significantly with respect to the original\n"
                                "// version, especially after program transformations such as dead\n"
                                "// code elimination and partial evaluation, hence the function may\n"
                                "// not have the initial behavior, if called under some other context.\n"
                                "//\n", 0));
  text_sentences(t) = 
    CONS(SENTENCE, make_sentence(is_sentence_formatted, comments),
         text_sentences(t));
  
  make_text_resource_and_free(new_name, DBR_C_SOURCE_FILE, ".c", t);
  free_statement(stat);
 
  /* give the clonee a user file.
   */
  DB_PUT_MEMORY_RESOURCE(DBR_USER_FILE, new_name, 
                         strdup(db_get_memory_resource(DBR_USER_FILE, name, true)));
 
}

References ALL_DECLS, concatenate(), CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, entity_local_name(), free_statement(), get_bool_property(), get_current_module_entity(), is_sentence_formatted, make_sentence(), make_text_resource_and_free(), module_name(), module_name_to_entity(), move_declarations(), reset_current_module_entity(), SENTENCE, set_bool_property(), set_current_module_entity(), STAT_ORDER, strdup(), text_named_module(), and text_sentences.

Referenced by comEngine_generate_HRECode(), and fill_HRE_module().

Here is the call graph for this function:

Here is the caller graph for this function:

create_integer_parameter_for_new_module()

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

Create new integer variable parameter for a newly created module.

Parameters

parameter_name	arameter_name
module_name	odule_name
module	odule
param_nb	aram_nb

Definition at line 126 of file phrase_distributor_control_code.c.

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

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
	)

phrase_distributor_control_code.c

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

create_private_integer_variable_for_new_module()

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

Creates an integer variable in specified module.

This entity does not exist, we can safely create it

Add to declarations....

Parameters

new_name	ew_name
new_module_name	ew_module_name
module	odule

Definition at line 775 of file phrase_distributor_communication.c.

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

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

Referenced by make_array_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

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.

Here is the call graph for this function:

create_realFifo_proc()

void create_realFifo_proc	(	statement	stat,
		list	lRef
	)

Parameters

stat	tat
lRef	Ref

Definition at line 1210 of file comEngine_generate_procCode.c.

{
  list lDone = NIL;
 
  pips_assert("true", stat==stat);
 
  //bool readAndWrite = false;
 
  MAP(REFERENCE, curRef1,
  {
    bool bDone = false;
 
    MAP(REFERENCE, refDone,
    {
      if(reference_equal_p(curRef1, refDone))
        {
          hash_put(gRefToFifoOff, hash_get(gRefToFifo, refDone), (void *)3);
          bDone = true;
          break;
        }
    }, lDone);
 
    if(bDone)
      continue;
 
    void* fifoNum = hash_get(gRefToFifo, curRef1);
 
    pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
                fifoNum != HASH_UNDEFINED_VALUE);
 
    hash_put(gRefToFifoOff, fifoNum, (void *)2);
 
    MAP(REFERENCE, curRef2,
    {
      if(reference_equal_p(curRef1, curRef2))
        {
          string effAction1 = hash_get(gRefToEff, curRef1);
 
          pips_assert("effAction1 != HASH_UNDEFINED_VALUE",
                      effAction1 != HASH_UNDEFINED_VALUE);
 
          string effAction2 = hash_get(gRefToEff, curRef2);
 
          pips_assert("effAction2 != HASH_UNDEFINED_VALUE",
                      effAction2 != HASH_UNDEFINED_VALUE);
 
          if(strcmp(effAction1, effAction2))
            {
              hash_put(gRefToFifoOff, fifoNum, (void *)3);
 
              lDone = CONS(REFERENCE, curRef1, lDone);
 
              break;
            }
        }
    }, lRef);
  }, lRef);
 
  gen_free_list(lDone);
 
  printf("create_realFifo_proc\n");
  MAP(REFERENCE, curRef,
  {
    printf("create_realFifo_proc it\n");
    print_reference(curRef);printf("\n");
    intptr_t fifoNum = (intptr_t)hash_get(gRefToFifo, curRef);
 
    pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
                fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
    get_realFifoNum(fifoNum);
  }, lRef);
 
  printf("create_realFifo_proc end\n");
}

References CONS, gen_free_list(), get_realFifoNum(), gRefToEff, gRefToFifo, gRefToFifoOff, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, intptr_t, MAP, NIL, pips_assert, print_reference(), printf(), REFERENCE, and reference_equal_p().

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

create_state_variable()

entity create_state_variable	(	const char *	module_name,
		int	name_identifier
	)

This function creates (and add declaration) state variable.

The name of this variable is obtained by the concatenation of string STATE_VARIABLE_NAME and name identifier. If the variable doesn't exist with this name, then the variable is created, added to declarations, and returned. If this variable exists, then this functions search a new name by incrementing the integer name_identifier

Assert that module represent a value code

This variable doesn't exist

Parameters

module_name	odule_name
name_identifier	ame_identifier

Definition at line 84 of file fsm_tools.c.

{
  entity module;
  entity new_state_variable;
  string state_variable_name;
  //char *buffer;
 
  module = module_name_to_entity(module_name);
 
  /* Assert that module represent a value code */
  pips_assert("it is a code", value_code_p(entity_initial(module)));
 
  if (name_identifier == 0) {
    state_variable_name = strdup (STATE_VARIABLE_NAME_NO_REF);
  }
  else {
    asprintf(&state_variable_name, STATE_VARIABLE_NAME, name_identifier);
  }
 
  if ((gen_find_tabulated(concatenate(module_name,
                                      MODULE_SEP_STRING,
                                      state_variable_name,
                                      NULL),
                          entity_domain)) == entity_undefined) {
   
    /* This variable doesn't exist */
   
    new_state_variable = find_or_create_scalar_entity (state_variable_name,
                                                       module_name,
                                                       is_basic_int);
    AddEntityToDeclarations( new_state_variable,module);
    return new_state_variable;
  }
  else {
    return create_state_variable (module_name,
                                  name_identifier+1);
  }
}

Referenced by create_state_variable(), and fsmize_statement().

Here is the caller graph for this function:

debug_control()

void debug_control	(	const char *	comments,
		control	a_control,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for a control a_control.

Parameters

comments	omments
a_control	_control
debug_level	ebug_level

Definition at line 134 of file phrase_tools.c.

                                                                              {
 
  debug_statement (comments, control_statement(a_control), debug_level);
  pips_debug(debug_level,"  predecessors          = %zd\n", gen_length(control_predecessors(a_control)));
  pips_debug(debug_level,"  successors            = %zd\n", gen_length(control_successors(a_control)));
 
}

References control_predecessors, control_statement, control_successors, debug_statement(), gen_length(), and pips_debug.

Referenced by flatten_unstructured(), full_spaghettify_module(), and make_transition_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_statement()

void debug_statement	(	const char *	comments,
		statement	stat,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for a statement stat.

Parameters

comments	omments
stat	tat
debug_level	ebug_level

Definition at line 111 of file phrase_tools.c.

{
  ifdebug(debug_level) {
    pips_debug(debug_level,"%s\n",comments);
    print_statement(stat);
    pips_debug(debug_level,"domain number         = %"PRIdPTR"\n", statement_domain_number(stat));
    pips_debug(debug_level,"entity                = UNDEFINED\n");
    pips_debug(debug_level,"statement number      = %"PRIdPTR"\n", statement_number(stat));
    pips_debug(debug_level,"statement ordering    = %"PRIdPTR"\n", statement_ordering(stat));
    if (statement_with_empty_comment_p(stat)) {
      pips_debug(debug_level,"statement comments   = EMPTY\n");
    }
    else {
      pips_debug(debug_level,"statement comments  = %s\n", statement_comments(stat));
    }
    pips_debug(debug_level,"statement instruction = %s\n", statement_type_as_string(stat));
  }
}

References ifdebug, pips_debug, print_statement(), statement_comments, statement_domain_number, statement_number, statement_ordering, statement_type_as_string(), and statement_with_empty_comment_p().

Referenced by full_spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_unstructured()

void debug_unstructured	(	unstructured	an_unstructured,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured.

f (ordering > 65535) ordering = ordering >> 16;

f (ordering > 65535) ordering = ordering >> 16;

f (ordering > 65535) ordering = ordering >> 16;

Parameters

an_unstructured	n_unstructured
debug_level	ebug_level

Definition at line 146 of file phrase_tools.c.

{
  list blocs = NIL ;
  string line = "***********************************************************************\n";
 
  ifdebug (debug_level) {
    CONTROL_MAP (current_control, {
      statement s = control_statement (current_control);
      string next_nodes_as_string = "";
      string previous_nodes_as_string = "";
      char *title;
      list predecessors = control_predecessors(current_control);
      list successors = control_successors(current_control);
      char *temp;
      size_t i;
      int ordering = 0;
 
      for (i=0; i<gen_length(predecessors); i++) {
        ordering = statement_ordering(control_statement
                                      (CONTROL(gen_nth(i,predecessors))));
        ordering = beautify_ordering (ordering);
        /*if (ordering > 65535) ordering = ordering >> 16;*/
        asprintf (&temp, "[%d] ",ordering);
        previous_nodes_as_string = strdup (concatenate(previous_nodes_as_string,
                                                       temp,
                                                       NULL));
    free(temp);
      }
     
      for (i=0; i<gen_length(successors); i++) {
        ordering = statement_ordering(control_statement
                                      (CONTROL(gen_nth(i,successors))));
        ordering = beautify_ordering (ordering);
        /*if (ordering > 65535) ordering = ordering >> 16;*/
        asprintf (&temp, "[%d] ",ordering);
        next_nodes_as_string = strdup (concatenate(next_nodes_as_string,
                                                   (temp),
                                                   NULL));
    free(temp);
      }
     
      ordering = beautify_ordering (ordering);
      ordering = statement_ordering(s);
      /*if (ordering > 65535) ordering = ordering >> 16;*/
      ifdebug(debug_level) {
      asprintf (&title, "CONTROL: %d\n", ordering);
        pips_debug(debug_level, "%s\n",
                   strdup(concatenate("\n", line,
                                      "* ", (title),
                                      line, NULL)));
        print_statement(s);
        pips_debug(debug_level, "%s\n",
                   strdup(concatenate("\n", line,
                                      "NEXT: ", next_nodes_as_string, "\n",
                                      "PREVIOUS: ", previous_nodes_as_string, "\n",
                                      line, NULL)));
    free(title);
      }
    }, unstructured_entry(an_unstructured), blocs);
  }
}

References asprintf, beautify_ordering(), concatenate(), CONTROL, CONTROL_MAP, control_predecessors, control_statement, control_successors, free(), gen_length(), gen_nth(), ifdebug, line, NIL, pips_debug, predecessors(), print_statement(), statement_ordering, strdup(), successors(), and unstructured_entry.

Here is the call 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:

entry_state_variable_value_for_unstructured()

int entry_state_variable_value_for_unstructured

(

statement

stat

)

Return the state variable value corresponding to the entry in a unstructured statement.

Parameters

stat

tat

Definition at line 162 of file fsm_tools.c.

{
  unstructured u;
 
  pips_assert("Statement is UNSTRUCTURED in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_unstructured);
 
  u = instruction_unstructured(statement_instruction(stat));
 
  return  beautify_ordering (statement_ordering(control_statement(unstructured_entry(u))));
}

Referenced by make_reset_state_variable_statement().

Here is the caller graph for this function:

exit_state_variable_value_for_unstructured()

int exit_state_variable_value_for_unstructured

(

statement

stat

)

Return the state variable value corresponding to the exit in a unstructured statement NB: always return 0.

Parameters

stat

tat

Definition at line 180 of file fsm_tools.c.

{
  pips_assert("Statement is UNSTRUCTURED in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_unstructured);
 
  return 0;
}

Referenced by make_fsm_from_statement(), and make_transition_statement().

Here is the caller graph for this function:

fsm_generation()

bool fsm_generation

(

const char *

module_name

)

fsm_generation.c

get the resources

dependence_graph = (graph) db_get_memory_resource(DBR_DG, module_name, true);

Now do the job

If property FSMIZE_WITH_GLOBAL_VARIABLE is set to true, we declare here the state variable which will be used in the whole module

Reorder the module, because new statements have been added

update/release resources

Parameters

module_name

odule_name

Definition at line 103 of file fsm_generation.c.

{
  entity state_variable = NULL;
 
   /* 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
  /* dependence_graph = 
     (graph) db_get_memory_resource(DBR_DG, module_name, true); */
  
  debug_on("FSM_GENERATION_DEBUG_LEVEL");
 
  /* Now do the job */
 
  /* If property FSMIZE_WITH_GLOBAL_VARIABLE is set to true, we
   * declare here the state variable which will be used in the whole
   * module */
  if (get_bool_property("FSMIZE_WITH_GLOBAL_VARIABLE")) {
    state_variable = create_state_variable(module_name, 0);
  }
 
  stat = fsmize_statement(stat, state_variable, module_name);
  
  pips_assert("Statement is consistent after FSM_GENERATION", 
               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(), create_state_variable(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, fsmize_statement(), get_bool_property(), module_name(), module_name_to_entity(), module_reorder(), pips_assert, 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:

fsm_merge_states()

bool fsm_merge_states

(

const char *

module_name

)

fsm_merge_states.c

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 54 of file fsm_merge_states.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("FSM_MERGE_STATES_DEBUG_LEVEL");
  /* Now do the job */
  
  pips_assert("Statement is consistent after FSM_MERGE_STATES", 
               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, module_name(), module_name_to_entity(), module_reorder(), pips_assert, 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:

fsm_split_state()

bool fsm_split_state

(

const char *

module_name

)

fsm_split_state.c

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 54 of file fsm_split_state.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("FSM_SPLIT_STATE_DEBUG_LEVEL");
  /* Now do the job */
  
  pips_assert("Statement is consistent after FSM_SPLIT_STATE", 
               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, module_name(), module_name_to_entity(), module_reorder(), pips_assert, 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:

fsmize_statement()

statement fsmize_statement	(	statement	stat,
		entity	state_variable,
		const char *	module_name
	)

This function is recursively called during FSMization.

It takes the statement to fsmize stat as parameter, while module_name is the name of the module where FSMization is applied. If global variable is used for the whole module, state_variable contains this element. If state_variable is null, then new state_variable is created for this statement.

= beautify_ordering (statement_ordering(stat));

Parameters

stat	tat
state_variable	tate_variable
module_name	odule_name

Definition at line 536 of file fsm_tools.c.

{
  // Defaut behaviour is to return parameter statement stat
  statement returned_statement = stat;
  instruction i = statement_instruction(stat);
 
  pips_debug(2,"\nFSMize: Module statement: =====================================\n");
  ifdebug(2) {
    print_statement(stat);
  }
  pips_debug(2,"domain number = %"PRIdPTR"\n", statement_domain_number(stat));
  pips_debug(2,"entity = UNDEFINED\n");
  pips_debug(2,"statement number = %"PRIdPTR"\n", statement_number(stat));
  pips_debug(2,"statement ordering = %"PRIdPTR"\n", statement_ordering(stat));
  if (statement_with_empty_comment_p(stat)) {
    pips_debug(2,"statement comments = EMPTY\n");
  }
  else {
    pips_debug(2,"statement comments = %s\n", statement_comments(stat));
  }
  pips_debug(2,"statement instruction = %s\n", statement_type_as_string(stat));
  switch (instruction_tag(i)) {
  case is_instruction_test:
    {
    // Declare the test data structure which will be used
    test current_test = instruction_test(i);
    statement true_statement, new_true_statement;
    statement false_statement, new_false_statement;
 
    pips_debug(2, "TEST\n");  
 
    // Compute new statement for true statement, and replace
    // the old one by the new one
    true_statement = test_true (current_test);
    new_true_statement = fsmize_statement(true_statement, state_variable, module_name);
    if (new_true_statement != NULL) {
      test_true (current_test) = new_true_statement;
    }
 
    // Do the same for the false statement
    false_statement = test_false (current_test);
    new_false_statement = fsmize_statement(false_statement, state_variable, module_name);
    if (new_false_statement != NULL) {
      test_false (current_test) = new_false_statement;
    }
   
    break;
  }
  case is_instruction_sequence:
    {
    sequence seq = instruction_sequence(i);
    pips_debug(2, "SEQUENCE\n");  
    MAP(STATEMENT, current_stat,
    {
      statement new_stat = fsmize_statement(current_stat, state_variable, module_name);
      if (new_stat != NULL) {
        gen_list_patch (sequence_statements(seq), current_stat, new_stat);
      }
    }, sequence_statements(seq));
    break;
  }
  case is_instruction_loop: {
    pips_debug(2, "LOOP\n");  
    break;
  }
  case is_instruction_whileloop: {
    pips_debug(2, "WHILELOOP\n");  
    break;
  }
  case is_instruction_forloop: {
    pips_debug(2, "FORLOOP\n");  
    break;
  }
  case is_instruction_call: {
    pips_debug(2, "CALL\n");  
    break;
  }
  case is_instruction_unstructured: {
    pips_debug(2, "UNSTRUCTURED\n"); 
    if (state_variable == NULL) {
      entity new_state_variable;
      int state_variable_identifier
        /* = beautify_ordering (statement_ordering(stat)); */
        = statement_ordering(stat);
     
      pips_debug(2, "Creating state variable with identifier %d\n",
                 state_variable_identifier);  
      new_state_variable
        = create_state_variable (module_name,
                                 state_variable_identifier);
      returned_statement = make_fsm_from_statement (stat,
                                                    new_state_variable,
                                                    module_name);
    }
    else {
      returned_statement = make_fsm_from_statement (stat,
                                                    state_variable,
                                                    module_name);
    }
    pips_debug(2, "Displaying statement\n");  
    ifdebug(2) {
      print_statement (returned_statement);
    }
    break;
  }
  case is_instruction_goto: {
    pips_debug(2, "GOTO\n");  
    break;
  }
  default:
    pips_debug(2, "UNDEFINED\n");  
    break;
  }
 
  return returned_statement;
}

Referenced by fsmize_statement(), and make_transition_statement().

Here is the caller graph for this function:

full_fsm_generation()

bool full_fsm_generation

(

const char *

module_name

)

full_fsm_generation.c

get the resources

Now do the job

In fact, there is nothing to do because this phase is the succession of the two phases FULL_SPAGHETTIFY and FSM_GENERATION

Reorder the module, because new statements have been added

update/release resources

Parameters

module_name

odule_name

Definition at line 64 of file full_fsm_generation.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));
  
  debug_on("FSM_GENERATION_DEBUG_LEVEL");
 
  /* Now do the job */
 
  /* In fact, there is nothing to do because this phase is the 
   * succession of the two phases FULL_SPAGHETTIFY and FSM_GENERATION
   */
 
  pips_assert("Statement is consistent after FULL_FSM_GENERATION", 
               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, module_name(), module_name_to_entity(), module_reorder(), pips_assert, 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:

full_spaghettify()

bool full_spaghettify

(

const char *

module_name

)

full_spaghettify.c

get the resources

Now do the job

Reorder the module, because new statements have been added

Restructure the module

Reorder the module, because new statements have been added

ATTENTION after simple_restructure_statement, statement stat is not longer a unstructured, but may be a sequence !!!

update/release resources

Parameters

module_name

odule_name

Definition at line 603 of file full_spaghettify.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));
 
  debug_on("SPAGUETTIFY_DEBUG_LEVEL");
 
  /* Now do the job */ 
  stat = full_spaghettify_module(stat, module_name);
 
  pips_assert("Statement is consistent after FULL_SPAGUETTIFY",
              statement_consistent_p(stat));
 
  pips_assert("Unstructured is consistent after FULL_SPAGUETTIFY",
              unstructured_consistent_p(statement_unstructured(stat)));
 
  /* Reorder the module, because new statements have been added */ 
  module_reorder(stat);
 
  ifdebug(5) {
    pips_debug(5,"====================================================\n");
    pips_debug(5,"Statement BEFORE simple_restructure_statement\n");
    print_statement (stat);
  }
 
  /* Restructure the module */
  simple_restructure_statement(stat);
  
  ifdebug(5) {
    pips_debug(5,"====================================================\n");
    pips_debug(5,"Statement AFTER simple_restructure_statement\n");
    print_statement (stat);
  }
 
  /* Reorder the module, because new statements have been added */ 
  module_reorder(stat);
 
  pips_assert("Statement is consistent after FULL_SPAGUETTIFY",
              statement_consistent_p(stat));
 
  /**
   * ATTENTION
   * after simple_restructure_statement, statement stat is
   * not longer a unstructured, but may be a sequence !!!
   */
 
  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, full_spaghettify_module(), ifdebug, module_name(), module_name_to_entity(), module_reorder(), pips_assert, pips_debug, print_statement(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), simple_restructure_statement(), statement_consistent_p(), statement_unstructured(), and unstructured_consistent_p().

Here is the call graph for this function:

generate_code_function()

statement generate_code_function	(	statement	stat,
		bool	bCalledFromSeq
	)

Parameters

stat	tat
bCalledFromSeq	CalledFromSeq

Definition at line 1137 of file comEngine_generate_code.c.

{
  statement newStat = statement_undefined;
 
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_sequence:
      {
        newStat = generate_code_seq(stat);
 
        break;
      }
    case is_instruction_loop:
      {
        newStat = generate_code_loop(stat);
        break;
      }
    case is_instruction_call:
      {
        newStat = generate_code_call(stat, bCalledFromSeq);
        break;
      }
    case is_instruction_test:
      {
        if(gGenHRE)
          {
            newStat = generate_code_test_HRE(stat);
          }
        else
          {
            newStat = generate_code_test_proc(stat);
          }
        break;
      }
    default:
      {
        pips_assert("FALSE", false);
        break;
      }
    }
 
  return newStat;
}

References generate_code_call(), generate_code_loop(), generate_code_seq(), generate_code_test_HRE(), generate_code_test_proc(), gGenHRE, instruction_tag, is_instruction_call, is_instruction_loop, is_instruction_sequence, is_instruction_test, pips_assert, statement_instruction, and statement_undefined.

Referenced by comEngine_generate_code(), generate_code_loop(), generate_code_seq(), generate_code_test_HRE(), and generate_code_test_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_code_test_HRE()

statement generate_code_test_HRE

(

statement

stat

)

Parameters

stat

tat

Definition at line 547 of file comEngine_generate_HRECode.c.

{
  //printf("generate_code_test\n");
  //print_statement(stat);printf("\n");
  statement newStat = statement_undefined;
 
  newStat = get_call_stat_HRE(stat);
 
  test newTest = statement_test(newStat);
 
  if(test_true(newTest) != statement_undefined)
    {
      free_statement(test_true(newTest));
 
      test_true(newTest) = make_empty_statement();
    }
 
  if(test_false(newTest) != statement_undefined)
    {
      free_statement(test_false(newTest));
 
      test_false(newTest) = make_empty_statement();
    }
 
  list lRef = hash_get(gStatToRef, stat);
 
  if(lRef != HASH_UNDEFINED_VALUE)
    {
      process_replacement_HRE(lRef, expression_undefined, &newStat);
 
      newStat = generate_stat_from_ref_list_HRE(lRef, newStat);
    }
 
  // Get the new statements for the true statement
  statement trueStat = generate_code_function(test_true(statement_test(stat)), false);
 
  // Get the new statements for the false statement
  statement falseStat = generate_code_function(test_false(statement_test(stat)), false);
 
  free_statement(test_true(newTest));
  free_statement(test_false(newTest));
 
  if(trueStat != statement_undefined)
    {
      test_true(newTest) = trueStat;
    }
  else
    {
      test_true(newTest) = make_empty_statement();
    }
 
  if(falseStat != statement_undefined)
    {
      test_false(newTest) = falseStat;
    }
  else
    {
      test_false(newTest) = make_empty_statement();
    }
 
  return newStat;
}

References expression_undefined, free_statement(), generate_code_function(), generate_stat_from_ref_list_HRE(), get_call_stat_HRE(), gStatToRef, hash_get(), HASH_UNDEFINED_VALUE, make_empty_statement, process_replacement_HRE(), statement_test(), statement_undefined, test_false, and test_true.

Referenced by generate_code_function().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_code_test_proc()

statement generate_code_test_proc

(

statement

stat

)

Parameters

stat

tat

Definition at line 1142 of file comEngine_generate_procCode.c.

{
  printf("generate_code_test\n");
  print_statement(stat);printf("\n");
  statement newStat = statement_undefined;
 
  newStat = get_call_stat_proc(stat);
 
  list lRef = hash_get(gStatToRef, stat);
 
  if(lRef != HASH_UNDEFINED_VALUE)
    {
      newStat = generate_stat_from_ref_list_proc(lRef, NIL, newStat);
    }
 
  // Get the new statements for the true statement
  statement trueStat = generate_code_function(test_true(statement_test(stat)), false);
 
  // Get the new statements for the false statement
  statement falseStat = generate_code_function(test_false(statement_test(stat)), false);
 
  list lStats = NIL;
 
  if(newStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, newStat, NIL));
    }
 
  if(trueStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, trueStat, NIL));
    }
 
  if(falseStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, falseStat, NIL));
    }
 
  newStat = make_block_statement(lStats);
 
  return newStat;
}

References CONS, gen_nconc(), generate_code_function(), generate_stat_from_ref_list_proc(), get_call_stat_proc(), gStatToRef, hash_get(), HASH_UNDEFINED_VALUE, make_block_statement(), NIL, print_statement(), printf(), STATEMENT, statement_test(), statement_undefined, test_false, and test_true.

Referenced by generate_code_function().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_fifo_stat2()

statement generate_fifo_stat2	(	reference	curRef,
		bool	bRead
	)

Parameters

curRef	urRef
bRead	Read

Definition at line 336 of file comEngine_HRE_distribute.c.

{
  statement newStat = statement_undefined;
 
  string name = NULL;
 
  expression buffExp = get_fifo_from_ref(curRef);
 
  //printf("generate_fifo_stat2\n");
  //print_reference(curRef);printf("\n");
 
  if(buffExp == expression_undefined)
    {
      return statement_undefined;
    }
 
  bool innerInd = false;
 
  expression indExp = get_indExp_from_ref(curRef, gRefToInd, &innerInd);
 
  expression fifoExp = get_fifoExp_from_ref(curRef, buffExp, gRefToToggle);
 
  entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
  pips_assert("hreBuffEnt != entity_undefined",
              hreBuffEnt != entity_undefined);
 
  if(bRead)
    {
      name = strdup(READ_FIFO);
    }
  else
    {
      name = strdup(WRITE_FIFO);
    }
 
  newStat = make_read_write_fifo_stat(name, fifoExp, indExp,
                                      entity_to_expression(hreBuffEnt));
 
  if(!innerInd)
    {
      if(bRead)
        {
          glReadStats = CONS(STATEMENT, newStat, glReadStats);
        }
      else
        {
          glWriteStats = CONS(STATEMENT, newStat, glWriteStats);
        }
 
      return statement_undefined;
    }
 
  return newStat;
}

References CONS, entity_to_expression(), entity_undefined, expression_undefined, get_fifo_from_ref(), get_fifoExp_from_ref(), get_HRE_buff_ent_from_ref(), get_indExp_from_ref(), glReadStats, glWriteStats, gRefToInd, gRefToToggle, make_read_write_fifo_stat(), pips_assert, READ_FIFO, STATEMENT, statement_undefined, strdup(), and WRITE_FIFO.

Referenced by generate_fifo_stats2().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_fifo_stats2()

void generate_fifo_stats2	(	list	lRef,
		list *	lReadStats,
		list *	lWriteStats
	)

Parameters

lRef	Ref
lReadStats	ReadStats
lWriteStats	WriteStats

Definition at line 432 of file comEngine_HRE_distribute.c.

{
  list lReadDone = NIL;
  list lWriteDone = NIL;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    //printf("fifo ref %d\n", (int)curRef);
    //print_reference(curRef);printf("\n");
 
    if(!strcmp(effAction, R_EFFECT))
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lReadDone);
 
        if(!alreadyDone)
          {
            //printf("read eff\n");
 
            lReadDone = gen_nconc(lReadDone, CONS(REFERENCE, curRef, NIL));
 
            statement readStat = generate_fifo_stat2(curRef, true);
 
            if(readStat == statement_undefined)
              {
                continue;
              }
 
            *lReadStats = gen_nconc(*lReadStats, CONS(STATEMENT, readStat, NIL));
            //print_statement(readStat);
          }
      }
    else
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lWriteDone);
 
        if(!alreadyDone)
          {
            //printf("write eff\n");
 
            lWriteDone = gen_nconc(lWriteDone, CONS(REFERENCE, curRef, NIL));
 
            statement writeStat = generate_fifo_stat2(curRef, false);
 
            if(writeStat == statement_undefined)
              {
                continue;
              }
 
            *lWriteStats = gen_nconc(*lWriteStats, CONS(STATEMENT, writeStat, NIL));
 
            //print_statement(writeStat);
          }
      }
 
  }, lRef);
 
  gen_free_list(lReadDone);
  gen_free_list(lWriteDone);
}

References CONS, gen_free_list(), gen_nconc(), generate_fifo_stat2(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, MAP, NIL, pips_assert, R_EFFECT, REFERENCE, reference_equal_p(), STATEMENT, and statement_undefined.

Referenced by replace_array_ref_with_fifos2().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_ind_fifo_stat2()

statement generate_ind_fifo_stat2	(	entity	oldInd,
		entity	newInd,
		bool	bRead
	)

Parameters

oldInd	ldInd
newInd	ewInd
bRead	Read

Definition at line 396 of file comEngine_HRE_distribute.c.

{
  statement newStat = statement_undefined;
 
  string name = NULL;
 
  intptr_t indNum = (intptr_t)hash_get(gIndToNum, oldInd);
 
  pips_assert("indNum != HASH_UNDEFINED_VALUE",
              indNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
  if(bRead)
    {
      name = strdup(READ_FIFO);
    }
  else
    {
      name = strdup(WRITE_FIFO);
    }
 
  intptr_t fifoNum = (intptr_t)hash_get(gEntToHREFifo, oldInd);
 
  pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
              fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
  newStat =
    make_read_write_fifo_stat(name,
                              int_to_expression(fifoNum),
                              int_to_expression(indNum),
                              entity_to_expression(newInd));
  return newStat;
}

References entity_to_expression(), gEntToHREFifo, gIndToNum, hash_get(), HASH_UNDEFINED_VALUE, int_to_expression(), intptr_t, make_read_write_fifo_stat(), pips_assert, READ_FIFO, statement_undefined, strdup(), and WRITE_FIFO.

Referenced by add_index_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_HRE()

statement generate_stat_from_ref_list_HRE	(	list	lRef,
		statement	stat
	)

Parameters

lRef	Ref
stat	tat

Definition at line 382 of file comEngine_generate_HRECode.c.

{
  bool writeFound = false;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    if(!strcmp(effAction, W_EFFECT))
      {
        writeFound = true;
        break;
      }
 
  }, lRef);
 
  statement stepStat = make_wait_step_statement();
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
  if(stat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stat, NIL));
    }
 
  if(writeFound)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
    }
 
  free_statement(stepStat);
 
  return make_block_statement(lStats);
}

References CONS, copy_statement(), free_statement(), gen_nconc(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, make_block_statement(), make_wait_step_statement(), MAP, NIL, pips_assert, REFERENCE, STATEMENT, statement_undefined, and W_EFFECT.

Referenced by generate_code_call(), generate_code_loop(), generate_code_test_HRE(), process_code_seq(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_HRE_list()

list generate_stat_from_ref_list_HRE_list	(	list	lRef,
		list	lInStats
	)

Parameters

lRef	Ref
lInStats	InStats

Definition at line 425 of file comEngine_generate_HRECode.c.

{
  bool writeFound = false;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    if(!strcmp(effAction, W_EFFECT))
      {
        writeFound = true;
        break;
      }
 
  }, lRef);
 
  statement stepStat = make_wait_step_statement();
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
 
  lStats = gen_nconc(lStats, lInStats);
 
  if(writeFound)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
    }
 
  free_statement(stepStat);
 
  return lStats;
}

References CONS, copy_statement(), free_statement(), gen_nconc(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, make_wait_step_statement(), MAP, NIL, pips_assert, REFERENCE, STATEMENT, and W_EFFECT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_proc()

statement generate_stat_from_ref_list_proc	(	list	lRef,
		list	lToggleEnt,
		statement	stat
	)

Parameters

lRef	Ref
lToggleEnt	ToggleEnt
stat	tat

Definition at line 989 of file comEngine_generate_procCode.c.

{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
 
  generate_mmcd_stats_from_ref(lRef, NULL,
                               int_to_expression(1),
                               lToggleEnt,
                               &lReadStats, &lWriteStats);
 
  statement stepStat1 = make_step_inc_statement(1);
  statement stepStat2 = make_step_inc_statement(2);
 
  lStats = gen_nconc(CONS(STATEMENT, stepStat1, NIL), lReadStats);
  if(stat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stat, NIL));
    }
  lStats = gen_nconc(lStats, lWriteStats);
 
  if(lWriteStats != NIL)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat2, NIL));
    }
 
  return make_block_statement(lStats);
}

References CONS, gen_nconc(), generate_mmcd_stats_from_ref(), int_to_expression(), make_block_statement(), make_step_inc_statement(), NIL, STATEMENT, and statement_undefined.

Referenced by generate_code_call(), generate_code_loop(), generate_code_test_proc(), process_code_seq(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_proc_list()

list generate_stat_from_ref_list_proc_list	(	list	lRef,
		list	lInStats
	)

Parameters

lRef	Ref
lInStats	InStats

Definition at line 1025 of file comEngine_generate_procCode.c.

{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
 
  generate_mmcd_stats_from_ref(lRef, NULL,
                               int_to_expression(1),
                               NIL,
                               &lReadStats, &lWriteStats);
 
  statement stepStat1 = make_step_inc_statement(1);
  statement stepStat2 = make_step_inc_statement(2);
 
  lStats = gen_nconc(CONS(STATEMENT, stepStat1, NIL), lReadStats);
 
  lStats = gen_nconc(lStats, lInStats);
 
  lStats = gen_nconc(lStats, lWriteStats);
 
  if(lWriteStats != NIL)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat2, NIL));
    }
 
  return lStats;
}

References CONS, gen_nconc(), generate_mmcd_stats_from_ref(), int_to_expression(), make_step_inc_statement(), NIL, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

get_call_stat_HRE()

statement get_call_stat_HRE

(

statement

stat

)

Parameters

stat

tat

Definition at line 513 of file comEngine_generate_HRECode.c.

{
  statement newStat = copy_statement(stat);
 
  statement_comments(newStat) = string_undefined;
 
  return newStat;
}

References copy_statement(), statement_comments, and string_undefined.

Referenced by generate_code_call(), and generate_code_test_HRE().

Here is the call graph for this function:

Here is the caller graph for this function:

get_call_stat_proc()

statement get_call_stat_proc

(

statement

)

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

string get_dynamic_variable_name

(

entity

dynamic_variable

)

Return DYN_VAR_PARAM_NAME name for a dynamic variable.

Parameters

dynamic_variable

ynamic_variable

Definition at line 501 of file phrase_distributor_communication.c.

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

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

Referenced by make_array_communication_module(), and make_array_communication_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_externalizable_function_name()

string get_externalizable_function_name

(

statement

stat

)

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

Parameters

stat

tat

Definition at line 449 of file distribution_context.c.

{
  return get_function_name_by_searching_tag
    (stat,EXTERNALIZED_CODE_PRAGMA_BEGIN);
}

get_externalized_and_analyzed_function_name()

string get_externalized_and_analyzed_function_name	(	statement	stat,
		int *	stats_nb
	)

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

Parameters

stat	tat
stats_nb	tats_nb

Definition at line 470 of file distribution_context.c.

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

get_externalized_function_name()

string get_externalized_function_name

(

statement

stat

)

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

Parameters

stat

tat

Definition at line 459 of file distribution_context.c.

{
  return get_function_name_by_searching_tag
    (stat,EXTERNALIZED_CODE_PRAGMA_CALL);
}

get_fifo_from_ref()

expression get_fifo_from_ref

(

reference

ref

)

Parameters

ref

ef

Definition at line 74 of file comEngine_generate_HRECode.c.

{
  expression retExp = expression_undefined;
 
  intptr_t fifoNum = (intptr_t)hash_get(gRefToHREFifo, ref);
 
  if(fifoNum != (intptr_t)HASH_UNDEFINED_VALUE)
    {
      retExp = int_to_expression(fifoNum);
    }
 
  return retExp;
}

References expression_undefined, gRefToHREFifo, hash_get(), HASH_UNDEFINED_VALUE, int_to_expression(), intptr_t, and ref.

Referenced by generate_fifo_stat(), and generate_fifo_stat2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_fifoExp_from_ref()

expression get_fifoExp_from_ref	(	reference	curRef,
		expression	buffExp,
		hash_table	ht
	)

comEngine_HRE_distribute.c

Parameters

curRef	urRef
buffExp	uffExp
ht	t

Definition at line 260 of file comEngine_HRE_distribute.c.

{
  entity ind = entity_undefined;
 
  HASH_MAP(ref1, ind1,
  {
    if(reference_equal_p(curRef, ref1))
      {
        ind = ind1;
        break;
      }
  }, ht);
 
  expression fifoExp;
 
  if(ind == entity_undefined)
    {
      fifoExp = buffExp;
    }
  else
    {
      entity new_ent = find_or_create_newInd(ind, false);
 
      list addArg = gen_make_list(expression_domain,
                                  buffExp,
                                  entity_to_expression(new_ent),
                                  NULL);
 
      fifoExp =
        call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                     addArg));
    }
 
  return fifoExp;
}

References call_to_expression(), entity_intrinsic(), entity_to_expression(), entity_undefined, expression_domain, find_or_create_newInd(), gen_make_list(), HASH_MAP, make_call(), PLUS_OPERATOR_NAME, and reference_equal_p().

Referenced by generate_fifo_stat2().

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

string get_function_name_by_searching_tag	(	statement	stat,
		const char *	tag
	)

phrase_distributor.c

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:

get_HRE_buff_ent_from_ref()

entity get_HRE_buff_ent_from_ref

(

reference

ref

)

Parameters

ref

ef

Definition at line 91 of file comEngine_generate_HRECode.c.

{
  entity buffEnt = entity_undefined;
 
  HASH_MAP(curRef, hreBuff,
  {
    if(reference_equal_p(curRef, ref))
      {
        buffEnt = hreBuff;
        break;
      }
 
  }, gRefToHREVar);
 
  return buffEnt;
}

References entity_undefined, gRefToHREVar, HASH_MAP, ref, and reference_equal_p().

Referenced by generate_fifo_stat(), generate_fifo_stat2(), replace_array_ref_with_fifos(), and replace_array_ref_with_fifos2().

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 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 make_scalar_communication_module().

Here is the call graph for this function:

Here is the caller graph for this function:

get_receive_param_module_name()

string get_receive_param_module_name	(	entity	,
		effect
	)

Referenced by controlize_distribution().

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

string get_ref_var_param_name

(

entity

reference_param

)

Return REF_VAR_PARAM_NAME name for a dynamic variable.

Parameters

reference_param

eference_param

Definition at line 513 of file phrase_distributor_communication.c.

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

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

Referenced by make_array_communication_module(), and make_array_communication_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_send_param_module_name()

string get_send_param_module_name	(	entity	,
		effect
	)

Referenced by controlize_distribution().

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

list get_statements_with_comments_containing	(	const char *	comment_portion,
		statement	stat
	)

First, set searched_string (we remove format information)

Reset list

fdebug(5) { pips_debug(5, "Searching statements with comments: %s\n", context.searched_string);
pips_debug(5, "In statement:\n");
print_statement(stat); }

Parameters

comment_portion	omment_portion
stat	tat

Definition at line 481 of file phrase_tools.c.

{
  statement_checking_context context;
 
  /* First, set searched_string (we remove format information)*/
  context.searched_string = strdup(comment_portion);
  context.searched_string[strcspn(comment_portion, "%s")] = '\0';
 
  /* Reset list */
  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);
 
  return context.list_of_statements;
 
}

References check_if_statement_contains_comment(), gen_context_recurse, gen_true2(), NIL, statement_domain, and strdup().

Referenced by controlize_distribution(), identify_analyzed_statements_to_distribute(), and identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

get_supportedRef_HRE()

void get_supportedRef_HRE	(	statement	stat,
		list *	lSupportedRef,
		list *	lUnSupportedRef
	)

Parameters

stat	tat
lSupportedRef	SupportedRef
lUnSupportedRef	UnSupportedRef

Definition at line 467 of file comEngine_generate_HRECode.c.

{
  *lSupportedRef = hash_get(gLoopToSupRef, stat);
  *lUnSupportedRef = hash_get(gLoopToUnSupRef, stat);
 
  pips_assert("*lSupportedRef != HASH_UNDEFINED_VALUE",
              *lSupportedRef != HASH_UNDEFINED_VALUE);
 
  pips_assert("*lUnSupportedRef != HASH_UNDEFINED_VALUE",
              *lUnSupportedRef != HASH_UNDEFINED_VALUE);
}

References gLoopToSupRef, gLoopToUnSupRef, hash_get(), HASH_UNDEFINED_VALUE, and pips_assert.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

get_supportedRef_proc()

void get_supportedRef_proc	(	statement	stat,
		hash_table	htOffset,
		list *	lSupportedRef,
		list *	lUnSupportedRef
	)

Parameters

stat	tat
htOffset	tOffset
lSupportedRef	SupportedRef
lUnSupportedRef	UnSupportedRef

Definition at line 1077 of file comEngine_generate_procCode.c.

{
  loop curLoop = statement_loop(stat);
 
  list lRef = hash_get(gLoopToRef, stat);
 
  if(lRef == HASH_UNDEFINED_VALUE)
    {
      lRef = NIL;
    }
 
  MAP(REFERENCE, curRef,
  {
    //printf("loop ref\n");
    //print_reference(curRef);printf("\n");
 
    if(supported_ref_p(curRef, loop_index(curLoop), htOffset))
      {
        *lSupportedRef = gen_nconc(*lSupportedRef, CONS(REFERENCE, curRef, NIL));
      }
    else
      {
        *lUnSupportedRef = gen_nconc(*lUnSupportedRef, CONS(REFERENCE, curRef, NIL));
      }
 
  }, lRef);
 
  hash_put(gLoopToSupRef, stat, *lSupportedRef);
  hash_put(gLoopToUnSupRef, stat, *lUnSupportedRef);
}

References CONS, gen_nconc(), gLoopToRef, gLoopToSupRef, gLoopToUnSupRef, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, loop_index, MAP, NIL, REFERENCE, statement_loop(), and supported_ref_p().

Referenced by do_HRE_memory_mapping_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

has_call_stat_inside()

bool has_call_stat_inside

(

statement

stat

)

comEngine_generate_procCode.c

Parameters

stat

tat

Definition at line 260 of file comEngine_generate_procCode.c.

{
  bool bHasCallStat = false;
 
  gen_context_recurse(stat, &bHasCallStat, statement_domain,
                      has_call_stat_inside_flt, has_call_stat_inside_rwt);
 
  return bHasCallStat;
}

References gen_context_recurse, has_call_stat_inside_flt(), has_call_stat_inside_rwt(), and statement_domain.

Here is the call graph for this function:

HRE_distribute()

statement HRE_distribute	(	statement	stat,
		string	new_module_name,
		const char *	module_name
	)

Parameters

stat	tat
new_module_name	ew_module_name
module_name	odule_name

Definition at line 955 of file comEngine_HRE_distribute.c.

{
  printf("stat bef HRE_distribute\n");
  print_statement(stat);
 
  // Global variables initialization
  g_new_module_name = new_module_name;
  g_module_name = module_name;
  gCurStats = NIL;
  glCurRep = NIL;
  gIfCount = 0;
  glCurLoop = NIL;
  gNewInd = entity_undefined;
  gOldIndToNewInd = hash_table_make(hash_pointer, 0);
  gIsIndex = hash_table_make(hash_pointer, 0);
  glReadStats = NIL;
  glWriteStats = NIL;
 
  HRE_distribute_stat(stat, true);
 
  loop_enter();
 
  // Free some global variables
  hash_table_free(gOldIndToNewInd);
  hash_table_free(gIsIndex);
 
  return make_block_statement(NIL);
}

References entity_undefined, g_module_name, g_new_module_name, gCurStats, gIfCount, gIsIndex, glCurLoop, glCurRep, glReadStats, glWriteStats, gNewInd, gOldIndToNewInd, hash_pointer, hash_table_free(), hash_table_make(), HRE_distribute_stat(), loop_enter(), make_block_statement(), module_name(), NIL, print_statement(), and printf().

Referenced by comEngine_generate_HRECode().

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:

internal_compute_distribution_context()

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
	)

Internally used to compute distribution context for statement externalized_code.

Storing results in hash_tables

Parameters

externalized_code	xternalized_code
ht_params	t_params
ht_private	t_private
ht_in_regions	t_in_regions
ht_out_regions	t_out_regions
key_value	ey_value

Definition at line 346 of file distribution_context.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);
    }
 
  /* Storing 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(), and compute_distribution_controlization_context().

Here is the call graph for this function:

Here is the caller graph for this function:

make_assignement_statement()

statement make_assignement_statement	(	entity	a_variable,
		expression	an_expression,
		statement	stat
	)

Build and return new statement which is a assignement of variable a_variable with expression an_expression, with empty label, statement number and ordering of statement stat, and empty comments.

Parameters

a_variable	_variable
an_expression	n_expression
stat	tat

Definition at line 392 of file phrase_tools.c.

{
  return make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                     entity_to_expression(a_variable),
                                     an_expression,
                                     stat);
}

References a_variable, ASSIGN_OPERATOR_NAME, entity_to_expression(), and make_binary_call_statement().

Referenced by make_body_from_loop(), make_global_common_and_initialize(), and make_initialization_from_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

make_binary_call_statement()

statement make_binary_call_statement	(	const char *	operator_name,
		expression	expression1,
		expression	expression2,
		statement	stat
	)

Build and return new statement which is a binary call with the 2 expressions expression1 and expression2, with empty label, statement number and ordering of statement stat, and empty comments.

Parameters

operator_name	perator_name
expression1	xpression1
expression2	xpression2
stat	tat

Definition at line 354 of file phrase_tools.c.

{
  call assignment_call
    = make_call (entity_intrinsic(operator_name),
                 CONS(EXPRESSION,
                      expression1,
                      CONS(EXPRESSION, expression2, NIL)));
 
  if (stat == NULL) {
    return make_statement(entity_empty_label(),
                          STATEMENT_NUMBER_UNDEFINED,
                          STATEMENT_ORDERING_UNDEFINED,
                          empty_comments,
                          make_instruction (is_instruction_call,
                                            assignment_call),
                          NIL,NULL,
                          empty_extensions (), make_synchronization_none()); 
  }
  else {
    return make_statement(entity_empty_label(),
                          statement_number(stat),
                          statement_ordering(stat),
                          empty_comments,
                          make_instruction (is_instruction_call,
                                            assignment_call),
                          NIL,NULL,
                          statement_extensions(stat), make_synchronization_none());
  }
}

References CONS, empty_comments, empty_extensions(), entity_empty_label(), entity_intrinsic(), EXPRESSION, is_instruction_call, make_call(), make_instruction(), make_statement(), make_synchronization_none(), NIL, statement_extensions, statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, and STATEMENT_ORDERING_UNDEFINED.

Referenced by make_array_communication_statement(), and make_communication_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

make_exec_mmcd()

statement make_exec_mmcd

(

void

)

Definition at line 967 of file comEngine_generate_procCode.c.

{
  static int number = 0;
 
  list arg = gen_make_list(expression_domain,
                           entity_to_expression(gStepEnt),
                           int_to_expression(number++),
                           NULL);
 
  statement mmcdStat =
    call_to_statement(
                      make_call(module_name_to_runtime_entity(strdup("GEN_EXEC_MMCD")),
                                arg));
 
  return mmcdStat;
}

References call_to_statement, entity_to_expression(), expression_domain, gen_make_list(), gStepEnt, int_to_expression(), make_call(), module_name_to_runtime_entity(), and strdup().

Referenced by add_exec_mmcd().

Here is the call graph for this function:

Here is the caller graph for this function:

make_expression_with_state_variable()

expression make_expression_with_state_variable	(	entity	state_variable,
		int	value,
		string	intrinsic_name
	)

fsm_tools.c

fsm_tools.c

state = 23), given an entity state_variable, an int value value, and an intrinsic name

Parameters

state_variable	tate_variable
intrinsic_name	ntrinsic_name

Definition at line 66 of file fsm_tools.c.

{
  return MakeBinaryCall (entity_intrinsic(intrinsic_name),
                         entity_to_expression (state_variable),
                         int_to_expression (value));
}

Referenced by make_fsm_from_statement(), and make_transition_statement().

Here is the caller graph for this function:

make_fsm_from_statement()

statement make_fsm_from_statement	(	statement	stat,
		entity	state_variable,
		const char *	module_name
	)

This function build and return a statement representing the FSM code equivalent to the given unstructured statement stat.

tring comment; char buffer[256];

Assert that given stat is UNSTRUCTURED

Create loop condition: state variable is not equal to exit value

Evaluation is done BEFORE to enter the loop

No label for loop

Computes the statement representing the transitions

Build the loop

printf (buffer, FSM_BEGIN_COMMENT, entity_local_name(state_variable)); comment = strdup(buffer);

tatement_instruction(loop_body) = make_instruction_block(CONS(STATEMENT,returned_statement,NIL));

Parameters

stat	tat
state_variable	tate_variable
module_name	odule_name

Definition at line 447 of file fsm_tools.c.

{
  statement returned_statement;
  statement loop_statement;
  whileloop new_whileloop;
  expression loop_condition;
  statement loop_body;
  entity loop_entity = NULL;
  evaluation loop_evaluation = NULL;
  instruction loop_instruction;
  instruction sequence_instruction;
  sequence new_sequence;
  /*string comment;
    char buffer[256];*/
 
  /* Assert that given stat is UNSTRUCTURED */
  pips_assert("Statement is UNSTRUCTURED in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_unstructured);
 
  /* Create loop condition: state variable is not equal to exit value */
  loop_condition
    = make_expression_with_state_variable
    (state_variable,
     exit_state_variable_value_for_unstructured(stat),
     NON_EQUAL_OPERATOR_NAME);
 
  /* Evaluation is done BEFORE to enter the loop */
  loop_evaluation = make_evaluation_before();
 
  /* No label for loop */
  loop_entity = entity_empty_label();
 
  /* Computes the statement representing the transitions */
  loop_body = make_fsm_transitions_statement (stat,
                                              state_variable,
                                              module_name);
 
  /* Build the loop */
  new_whileloop = make_whileloop(loop_condition,
                                 loop_body,
                                 loop_entity,
                                 loop_evaluation);
 
  loop_instruction = make_instruction(is_instruction_whileloop,new_whileloop);
 
  /*sprintf (buffer, FSM_BEGIN_COMMENT, entity_local_name(state_variable));
    comment = strdup(buffer);*/
 
  loop_statement = make_statement(statement_label(stat),
                                  statement_number(stat),
                                  statement_ordering(stat),
                                  empty_comments,
                                  loop_instruction,NIL,NULL,
                                  statement_extensions(stat), make_synchronization_none());
 
 
  new_sequence
    = make_sequence (CONS(STATEMENT,
                          make_reset_state_variable_statement(stat,
                                                              state_variable),
                          CONS(STATEMENT, loop_statement, NIL)));
   
  sequence_instruction
    = make_instruction(is_instruction_sequence,
                       new_sequence);
 
  returned_statement = make_statement(entity_empty_label(),
                                      statement_number(stat),
                                      statement_ordering(stat),
                                      empty_comments,
                                      sequence_instruction,NIL,NULL,
                                      statement_extensions(stat), make_synchronization_none());
  /*statement_instruction(loop_body)
    = make_instruction_block(CONS(STATEMENT,returned_statement,NIL));
  */
  return returned_statement;
}

Referenced by fsmize_statement().

Here is the caller graph for this function:

make_fsm_transitions_statement()

statement make_fsm_transitions_statement	(	statement	stat,
		entity	state_variable,
		const char *	module_name
	)

This function build and return a statement representing the transitions computation in the FSM, given the UNSTRUCTURED statement stat.

en_recurse(unstructured_entry(nodes_graph), control_domain, transitions_filter, transitions_statements);

Parameters

stat	tat
state_variable	tate_variable
module_name	odule_name

Definition at line 400 of file fsm_tools.c.

{
  statement returned_statement = NULL;
  statement current_statement = NULL;
  unstructured nodes_graph;
  list blocs = NIL ;
 
  pips_assert("Statement is UNSTRUCTURED in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_unstructured);
 
  nodes_graph = instruction_unstructured(statement_instruction(stat));
 
  /*gen_recurse(unstructured_entry(nodes_graph), control_domain,
    transitions_filter, transitions_statements);*/
  CONTROL_MAP (current_control, {
    statement transition_statement;
    transition_statement = make_transition_statement (current_control,
                                                      stat,
                                                      state_variable,
                                                      module_name);
    if (returned_statement == NULL) {
      returned_statement = transition_statement;
      current_statement = returned_statement;
    }
    else {
      instruction i = statement_instruction(current_statement);
      test t;
      pips_assert("Statement is TEST in FSM_GENERATION transitions",
                  instruction_tag(i) == is_instruction_test);
      t = instruction_test(i);
      test_false (t) = transition_statement;
      current_statement = transition_statement;
    }
  }, unstructured_entry(nodes_graph), blocs);
 
  pips_debug(2,"blocs count = %zd\n", gen_length(blocs));
 
  return returned_statement;
}

Referenced by make_fsm_from_statement().

Here is the caller graph for this function:

make_init_newInd_stat()

statement make_init_newInd_stat	(	statement	stat,
		entity	newInd
	)

Parameters

stat	tat
newInd	ewInd

Definition at line 701 of file comEngine_generate_procCode.c.

{
  //printf("make_init_newInd_stat beg\n");
 
  list lUnSupportedRef = hash_get(gLoopToUnSupRef, stat);
 
  pips_assert("lUnSupportedRef != HASH_UNDEFINED_VALUE",
              lUnSupportedRef != HASH_UNDEFINED_VALUE);
 
  if((!has_loop_inside(loop_body(statement_loop(stat)))) &&
     (lUnSupportedRef == NIL))
    {
      return statement_undefined;
    }
 
  int fifoNum = find_or_create_slot(loop_index(statement_loop(stat)));
 
  statement newStat =
    make_mmcd_load_store_stat(strdup(GEN_LOAD_MMCD),
                              int_to_expression(fifoNum),
                              entity_to_expression(newInd),
                              int_to_expression(1),
                              int_to_expression(1));
 
  //printf("make_init_newInd_stat end\n");
  return newStat;
}

References entity_to_expression(), find_or_create_slot(), GEN_LOAD_MMCD, gLoopToUnSupRef, has_loop_inside(), hash_get(), HASH_UNDEFINED_VALUE, int_to_expression(), loop_body, loop_index, make_mmcd_load_store_stat(), NIL, pips_assert, statement_loop(), statement_undefined, and strdup().

Referenced by add_toggle_inc_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

make_loop_lStats_HRE()

list make_loop_lStats_HRE	(	statement	,
		entity	,
		statement	,
		entity	,
		list	,
		hash_table	,
		expression
	)

make_loop_lStats_proc()

list make_loop_lStats_proc	(	statement	stat,
		entity	transferSize,
		statement	innerStat,
		entity	newOuterInd,
		list	lSupportedRef,
		hash_table	htOffset,
		expression	bufferSizeExp
	)

Parameters

stat	tat
transferSize	ransferSize
innerStat	nnerStat
newOuterInd	ewOuterInd
lSupportedRef	SupportedRef
htOffset	tOffset
bufferSizeExp	ufferSizeExp

Definition at line 1114 of file comEngine_generate_procCode.c.

{
  return make_lStats(stat, transferSize,
                     innerStat, newOuterInd,
                     lSupportedRef, htOffset,
                     bufferSizeExp);
}

References make_lStats().

Referenced by make_loopStat1().

Here is the call graph for this function:

Here is the caller graph for this function:

make_loop_step_stat()

statement make_loop_step_stat	(	statement	stat,
		entity	newOuterInd
	)

Parameters

stat	tat
newOuterInd	ewOuterInd

Definition at line 554 of file comEngine_generate_procCode.c.

{
  loop curLoop = statement_loop(stat);
 
  statement stepStat;
 
  if(gGenHRE)
    {
      stepStat = make_wait_step_statement();
    }
  else
    {
      stepStat = make_step_inc_statement(1);
    }
 
  list neArg = gen_make_list(expression_domain,
                             entity_to_expression(newOuterInd),
                             copy_expression(range_lower(loop_range(curLoop))),
                             NULL);
 
  expression neExp = 
    call_to_expression(make_call(entity_intrinsic(C_GREATER_THAN_OPERATOR_NAME),
                                 neArg));
 
  test t = make_test(neExp, stepStat, make_empty_statement());
 
  stepStat = make_statement(entity_empty_label(), 
                            STATEMENT_NUMBER_UNDEFINED,
                            STATEMENT_ORDERING_UNDEFINED,
                            empty_comments,
                            make_instruction(is_instruction_test, t),
                            NIL,NULL,
                            empty_extensions (), make_synchronization_none());
 
  return stepStat;
}

References C_GREATER_THAN_OPERATOR_NAME, call_to_expression(), copy_expression(), empty_comments, empty_extensions(), entity_empty_label(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), gGenHRE, is_instruction_test, loop_range, make_call(), make_empty_statement, make_instruction(), make_statement(), make_step_inc_statement(), make_synchronization_none(), make_test(), make_wait_step_statement(), NIL, range_lower, statement_loop(), STATEMENT_NUMBER_UNDEFINED, and STATEMENT_ORDERING_UNDEFINED.

Here is the call graph for this function:

make_receive_array_params_modules()

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

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

Parameters

function	unction
l_regions	_regions
global_common	lobal_common
externalized_fonction_common	xternalized_fonction_common
number_of_deployment_units	umber_of_deployment_units

Definition at line 961 of file phrase_distributor_communication.c.

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

References make_array_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_receive_scalar_params_modules()

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

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

Parameters

ht_out_communications	t_out_communications
number_of_deployment_units	umber_of_deployment_units
global_common	lobal_common
l_commons	_commons

Definition at line 609 of file phrase_distributor_communication.c.

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

References l_commons, and make_scalar_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_reset_state_variable_statement()

statement make_reset_state_variable_statement	(	statement	stat,
		entity	state_variable
	)

This function build and return a statement representing the initial assigment of the state_variable, given the UNSTRUCTURED statement stat.

Parameters

stat	tat
state_variable	tate_variable

Definition at line 194 of file fsm_tools.c.

{
  return make_state_variable_assignement_statement
    (stat,
     state_variable,
     entry_state_variable_value_for_unstructured(stat));
}

Referenced by make_fsm_from_statement().

Here is the caller graph for this function:

make_send_array_params_modules()

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

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

Parameters

function	unction
l_regions	_regions
global_common	lobal_common
externalized_fonction_common	xternalized_fonction_common
number_of_deployment_units	umber_of_deployment_units

Definition at line 943 of file phrase_distributor_communication.c.

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

References make_array_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_send_scalar_params_modules()

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

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

Parameters

ht_in_communications	t_in_communications
number_of_deployment_units	umber_of_deployment_units
global_common	lobal_common
l_commons	_commons

Definition at line 593 of file phrase_distributor_communication.c.

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

References l_commons, and make_scalar_communication_modules().

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_start_ru_module()

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

phrase_distributor_communication.c

phrase_distributor_communication.c

Build and store new module START_RU. Create statement module_statement

Declare CONTROL_DATA common to be visible here

Declare commons for all externalized functions to be visible here

Compute the parameters of call function

Processing PARAMS regions

Make the CALL statement

Parameters

ht_params	t_params
module_statement	odule_statement
number_of_deployment_units	umber_of_deployment_units
global_common	lobal_common
l_commons	_commons

Definition at line 71 of file phrase_distributor_communication.c.

{
  entity start_ru_module;
  entity func_id;
  entity unit_id = NULL;
  const char* function_name;
  list stat_seq = NIL;
  sequence new_sequence;
  instruction sequence_instruction;
  entity set_entity = get_current_module_entity();
 
  start_ru_module = make_empty_subroutine(START_RU_MODULE_NAME,make_language_unknown());
  pips_debug(2, "Creating module %s\n", entity_global_name(start_ru_module));
  reset_current_module_entity();
  set_current_module_entity(start_ru_module);
  func_id = create_integer_parameter_for_new_module (START_RU_PARAM1_NAME,
                                                     START_RU_MODULE_NAME,
                                                     start_ru_module,
                                                     1);
  if (number_of_deployment_units > 1) {
    unit_id = create_integer_parameter_for_new_module (START_RU_PARAM2_NAME,
                                                       START_RU_MODULE_NAME,
                                                       start_ru_module,
                                                       2);
  }
 
  /* Declare CONTROL_DATA common to be visible here */
  declare_common_variables_in_module (global_common, start_ru_module);
 
  /* Declare commons for all externalized functions to be visible here */
  MAP (ENTITY, com, {
    declare_common_variables_in_module (com, start_ru_module);
  },l_commons);
 
  ifdebug(7) {
    pips_debug(7, "Declarations for START_RU module: \n");
    fprint_environment(stderr, start_ru_module);
  }
 
  HASH_MAP (externalized_function, l_params, {
   
    entity function = (entity)externalized_function;
    expression test_condition;
    test new_test;
    instruction test_instruction;
    statement test_statement;
    statement call_statement;
    list call_params ;
     
    function_name = entity_local_name(function);
#if 0
    statement called_module_stat = (statement) db_get_memory_resource(DBR_CODE,
                                                            function_name,
                                                            true);
   
#endif
    entity called_module = local_name_to_top_level_entity(function_name);
 
    /* Compute the parameters of call function */
    call_params = NIL;
 
    /* Processing PARAMS regions */
    MAP (REGION, reg, {
      expression new_param;
      reference ref = effect_any_reference(reg);
      entity local_variable
        = entity_in_module (get_common_param_name(reference_variable(ref), function), start_ru_module);
      list indices = NIL;
      if (number_of_deployment_units > 1) {
        list primary_indices = variable_dimensions(type_variable(entity_type(local_variable)));
        expression to_be_replaced = NULL;
        MAP (DIMENSION, dim, {
          indices = CONS (EXPRESSION,
                          dimension_lower(dim),
                          indices);
          to_be_replaced=dimension_lower(dim);
        }, primary_indices);
        gen_list_patch (indices,to_be_replaced,entity_to_expression(unit_id));
        indices = gen_nreverse(indices);
      } 
      new_param = make_entity_expression (local_variable, indices);
      call_params = CONS(EXPRESSION, new_param, call_params);
    }, (list)l_params);
 
    call_params = gen_nreverse(call_params);
   
    /* Make the CALL statement */
    call_statement = make_statement(entity_empty_label(),
                                    STATEMENT_NUMBER_UNDEFINED,
                                    STATEMENT_ORDERING_UNDEFINED,
                                    empty_comments,
                                    make_instruction(is_instruction_call,
                                                     make_call(called_module,call_params)),
                                    NIL,NULL,
                                    empty_extensions (), make_synchronization_none());
 
    test_condition
      = MakeBinaryCall (entity_intrinsic(EQUAL_OPERATOR_NAME),
                        entity_to_expression (func_id),
                        entity_to_expression (entity_in_module (get_function_id_name(function), start_ru_module)));
   
    new_test = make_test (test_condition, call_statement,
                          make_continue_statement(entity_undefined));
   
    test_instruction = make_instruction (is_instruction_test,new_test);
 
    test_statement = make_statement (entity_empty_label(),
                                     STATEMENT_NUMBER_UNDEFINED,
                                     STATEMENT_ORDERING_UNDEFINED,
                                     empty_comments,
                                     test_instruction,NIL,NULL,
                                     empty_extensions (), make_synchronization_none());
 
    stat_seq = CONS (STATEMENT, test_statement, stat_seq);
 
  }, ht_params);
 
  stat_seq =  gen_nreverse(CONS(STATEMENT, make_return_statement(start_ru_module), stat_seq));
 
  new_sequence
    = make_sequence (stat_seq);
 
  sequence_instruction
    = make_instruction(is_instruction_sequence,
                       new_sequence);
 
  *module_statement = make_statement(entity_empty_label(),
                                     STATEMENT_NUMBER_UNDEFINED,
                                     STATEMENT_ORDERING_UNDEFINED,
                                     empty_comments,
                                     sequence_instruction,NIL,NULL,
                                     empty_extensions (), make_synchronization_none());
 
  store_new_module (strdup(START_RU_MODULE_NAME), start_ru_module, *module_statement);
 
  reset_current_module_entity();
  set_current_module_entity(set_entity);
  return start_ru_module;
}

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

Referenced by controlize_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

make_state_variable_assignement_statement()

statement make_state_variable_assignement_statement	(	statement	stat,
		entity	state_variable,
		int	assignement_value
	)

This function build and return a statement representing the initial assigment of the state_variable, given the UNSTRUCTURED statement stat.

tatement_label(stat),

Parameters

stat	tat
state_variable	tate_variable
assignement_value	ssignement_value

Definition at line 129 of file fsm_tools.c.

{
  statement returned_statement;
  instruction new_instruction;
  call assignment_call;
 
  assignment_call = make_call (entity_intrinsic(ASSIGN_OPERATOR_NAME),
                               CONS(EXPRESSION,
                                    entity_to_expression(state_variable),
                                    CONS(EXPRESSION, int_to_expression (assignement_value), NIL)));
 
  new_instruction
    = make_instruction(is_instruction_call,
                       assignment_call);
 
  returned_statement = make_statement(entity_empty_label(),
                                      /*statement_label(stat),*/
                                      statement_number(stat),
                                      statement_ordering(stat),
                                      empty_comments,
                                      new_instruction,
                                      NIL,NULL,
                                      statement_extensions(stat), make_synchronization_none());
 
  return returned_statement;
}

Referenced by make_reset_state_variable_statement(), and make_transition_statement().

Here is the caller graph for this function:

make_step_inc_statement()

statement make_step_inc_statement

(

int

incNum

)

Parameters

incNum

ncNum

Definition at line 537 of file comEngine_generate_procCode.c.

{
  list addArg = gen_make_list(expression_domain,
                              entity_to_expression(gStepEnt),
                              int_to_expression(incNum),
                              NULL);
 
  expression rExp = call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                                 addArg));
 
  return make_assign_statement(entity_to_expression(gStepEnt), rExp);
}

References call_to_expression(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), gStepEnt, int_to_expression(), make_assign_statement(), make_call(), and PLUS_OPERATOR_NAME.

Referenced by add_exec_mmcd(), generate_code_call(), generate_stat_from_ref_list_proc(), generate_stat_from_ref_list_proc_list(), make_loop_step_stat(), and process_gLoopToSync_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

make_toggle_inc_statement()

statement make_toggle_inc_statement	(	entity	toggleEnt,
		int	val
	)

Parameters

toggleEnt	oggleEnt
val	al

Definition at line 222 of file comEngine_generate_code.c.

{
  list modArg = gen_make_list(expression_domain,
                              entity_to_expression(toggleEnt),
                              int_to_expression(val),
                              NULL);
 
  expression modExp =
    call_to_expression(make_call(entity_intrinsic(C_MODULO_OPERATOR_NAME),
                                 modArg));
 
  return make_assign_statement(entity_to_expression(toggleEnt),
                               modExp);
}

References C_MODULO_OPERATOR_NAME, call_to_expression(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), int_to_expression(), make_assign_statement(), and make_call().

Referenced by add_toggle_inc_statements(), and regenerate_toggles().

Here is the call graph for this function:

Here is the caller graph for this function:

make_toggle_init_statement()

statement make_toggle_init_statement

(

entity

toggleEnt

)

Parameters

toggleEnt

oggleEnt

Definition at line 189 of file comEngine_generate_code.c.

{
  return make_assign_statement(entity_to_expression(toggleEnt),
                               int_to_expression(0));
}

References entity_to_expression(), int_to_expression(), and make_assign_statement().

Referenced by regenerate_toggles(), and update_toggle_init_stats_list().

Here is the call graph for this function:

Here is the caller graph for this function:

make_toggle_mmcd()

statement make_toggle_mmcd

(

entity

ent

)

Parameters

ent

nt

Definition at line 668 of file comEngine_generate_procCode.c.

{
  int fifoNum = alloc_new_slot(ent);
 
  statement newStat =
    make_mmcd_load_store_stat(strdup(GEN_LOAD_MMCD),
                              int_to_expression(fifoNum),
                              entity_to_expression(ent),
                              int_to_expression(1),
                              int_to_expression(1));
 
  return newStat;
}

References alloc_new_slot(), entity_to_expression(), GEN_LOAD_MMCD, int_to_expression(), make_mmcd_load_store_stat(), and strdup().

Referenced by add_toggle_inc_statements(), and regenerate_toggles().

Here is the call graph for this function:

Here is the caller graph for this function:

make_transition_statement()

statement make_transition_statement	(	control	current_node,
		statement	root_statement,
		entity	state_variable,
		const char *	module_name
	)

This function build a transition statement (a TEST statement) corresponding to the current control current_node and the root_statement root_statement.

This TEST statement takes a condition on the state_variable having the value matching the statement ordering value, and the control statement for the test_true value. The test_false value is set with a continue statement, before to be eventually replaced in next control node by a new statement.

tring comment; char buffer[50];

This is the exit node, or a non-test statement

This is the exit node, just generate exit code for state_variable

successors_nb == 1

This is a "normal" node, ie not a TEST statement, just add assignement for state_variable with new value

NULL here because we will generate a new state variable, since the potential other FSMs are deeper

This is a "test" node, ie with a TEST statement, just add assignement for state_variable with new value after each statement in TEST

:-)

printf (buffer, FSM_TRANSITION_COMMENT, entity_local_name(state_variable), current_transition_number); comment = strdup(buffer);

tatement_label(root_statement),

Parameters

current_node	urrent_node
root_statement	oot_statement
state_variable	tate_variable
module_name	odule_name

Definition at line 212 of file fsm_tools.c.

{
  statement returned_statement = NULL;
  statement transition_statement = NULL;
  statement stat = control_statement (current_node);
  instruction test_instruction;
  instruction transition_instruction;
  sequence transition_sequence;
  test new_test;
  expression test_condition;
  int successors_nb;
  int current_transition_number;
  /*string comment;
    char buffer[50];*/
 
  debug_control ("TRANSITION: Module statement", current_node, 2);
 
  current_transition_number = beautify_ordering (statement_ordering(stat));
 
  test_condition
    = make_expression_with_state_variable (state_variable,
                                           current_transition_number,
                                           EQUAL_OPERATOR_NAME);
 
  successors_nb = gen_length(control_successors(current_node));
 
  if ((successors_nb == 0) || (successors_nb == 1)) {
    /* This is the exit node, or a non-test statement */
    int next_value;
    statement state_variable_assignement;
   
    if (successors_nb == 0) {
      /* This is the exit node, just generate exit code for state_variable */
      next_value = exit_state_variable_value_for_unstructured (root_statement);
    }
    else { /* successors_nb == 1 */
      /* This is a "normal" node, ie not a TEST statement, just add
         assignement for state_variable with new value */
      next_value
        = beautify_ordering (statement_ordering
                             (control_statement
                              (CONTROL(gen_nth(0,control_successors(current_node))))));
    }
   
    state_variable_assignement
      = make_state_variable_assignement_statement
      (stat, state_variable, next_value);
   
    transition_sequence
      = make_sequence (CONS(STATEMENT,
                            fsmize_statement(stat, NULL, module_name),
                            /* NULL here because we will generate
                             * a new state variable, since the potential
                             * other FSMs are deeper */
                            CONS(STATEMENT, state_variable_assignement, NIL)));
   
    transition_instruction
      = make_instruction(is_instruction_sequence,
                         transition_sequence);
 
    transition_statement = make_statement(entity_empty_label(),
                                          statement_number(stat),
                                          statement_ordering(stat),
                                          empty_comments,
                                          transition_instruction,NIL,NULL,
                                          statement_extensions(stat), make_synchronization_none());
  }
  else if (successors_nb == 2) {
    /* This is a "test" node, ie with a TEST statement, just add
       assignement for state_variable with new value after each
       statement in TEST */
    int value_if_true = beautify_ordering (statement_ordering
      (control_statement
       (CONTROL(gen_nth(0,control_successors(current_node))))));
    int value_if_false = beautify_ordering (statement_ordering
      (control_statement
       (CONTROL(gen_nth(1,control_successors(current_node))))));
    statement transition_statement_if_true;
    statement transition_statement_if_false;
    sequence transition_sequence_if_true;
    sequence transition_sequence_if_false;
    instruction transition_instruction_if_true;
    instruction transition_instruction_if_false;
    statement state_variable_assignement_if_true;
    statement state_variable_assignement_if_false;
    statement old_statement_if_true;
    statement old_statement_if_false;
    test current_test;
   
    pips_assert("Statement with 2 successors is a TEST in FSM_GENERATION",
                instruction_tag(statement_instruction(stat))
                == is_instruction_test);
   
    current_test = instruction_test (statement_instruction(stat));
 
    // Begin computing for the true statement
 
    old_statement_if_true = test_true(current_test);
   
    state_variable_assignement_if_true
      = make_state_variable_assignement_statement
      (stat, state_variable, value_if_true);
   
    transition_sequence_if_true
      = make_sequence (CONS(STATEMENT,
                            old_statement_if_true,
                            CONS(STATEMENT, state_variable_assignement_if_true, NIL)));
 
    transition_instruction_if_true
      = make_instruction(is_instruction_sequence,
                         transition_sequence_if_true);
 
    transition_statement_if_true = make_statement (entity_empty_label(),
                                                   statement_number(stat),
                                                   statement_ordering(stat),
                                                   empty_comments,
                                                   transition_instruction_if_true,
                                                   NIL,NULL,
                                                   statement_extensions(stat), make_synchronization_none());
   
    test_true(current_test) = transition_statement_if_true;
 
    // Begin computing for the false statement
 
    old_statement_if_false = test_false(current_test);
   
    state_variable_assignement_if_false
      = make_state_variable_assignement_statement
      (stat, state_variable, value_if_false);
   
    transition_sequence_if_false
      = make_sequence (CONS(STATEMENT,
                            old_statement_if_false,
                            CONS(STATEMENT, state_variable_assignement_if_false, NIL)));
 
    transition_instruction_if_false
      = make_instruction(is_instruction_sequence,
                         transition_sequence_if_false);
 
    transition_statement_if_false
      = make_statement
      (entity_empty_label(),
       statement_number(stat),
       statement_ordering(stat),
       empty_comments,
       transition_instruction_if_false,NIL,NULL,
       statement_extensions(stat), make_synchronization_none());
 
    test_false(current_test) = transition_statement_if_false;
 
    transition_statement = stat;
 
  }
  else {
    pips_assert("I should NOT be there :-)", 2+2 != 4); /* :-) */
  }
 
  new_test = make_test (test_condition, transition_statement,
                        make_continue_statement(entity_undefined));
 
  test_instruction = make_instruction (is_instruction_test,new_test);
 
  /*sprintf (buffer,
    FSM_TRANSITION_COMMENT,
    entity_local_name(state_variable),
    current_transition_number);
    comment = strdup(buffer);*/
 
  returned_statement = make_statement (entity_empty_label(),
                                       /*statement_label(root_statement),*/
                                       statement_number(root_statement),
                                       statement_ordering(root_statement),
                                       empty_comments,
                                       test_instruction,NIL,NULL,
                                       statement_extensions(root_statement), make_synchronization_none());
 
  return returned_statement;
 
}

Referenced by make_fsm_transitions_statement().

Here is the caller graph for this function:

make_transStat()

statement make_transStat	(	statement	stat,
		entity	newOuterInd,
		entity	transferSize,
		expression	bufferSizeExp
	)

tatement stepStat = make_loop_step_stat(stat, newOuterInd);

newStat = make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL), CONS(STATEMENT, newStat, NIL)));

f(!gGenHRE) { statement indStat = make_init_newInd_stat(stat, newOuterInd);

if(indStat != statement_undefined) { newStat = make_block_statement(gen_nconc(CONS(STATEMENT, newStat, NIL), CONS(STATEMENT, indStat, NIL))); } }

Parameters

stat	tat
newOuterInd	ewOuterInd
transferSize	ransferSize
bufferSizeExp	ufferSizeExp

Definition at line 733 of file comEngine_generate_procCode.c.

{
  statement newStat = statement_undefined;
 
  loop curLoop = statement_loop(stat);
 
  list rgSizeArg1 = gen_make_list(expression_domain,
                                  copy_expression(range_upper(loop_range(curLoop))),
                                  copy_expression(bufferSizeExp),
                                  NULL);
 
  expression rgSizeExp1 = 
    call_to_expression(make_call(entity_intrinsic(DIVIDE_OPERATOR_NAME),
                                 rgSizeArg1));
 
 
  list arg2Arg = gen_make_list(expression_domain,
                               copy_expression(bufferSizeExp),
                               rgSizeExp1,
                               NULL);
 
  expression arg2 = call_to_expression(make_call(entity_intrinsic(MULTIPLY_OPERATOR_NAME),
                                                 arg2Arg));
 
  list leArg = gen_make_list(expression_domain,
                             arg2,
                             entity_to_expression(newOuterInd),
                             NULL);
 
  expression leExp = 
    call_to_expression(make_call(entity_intrinsic(C_LESS_OR_EQUAL_OPERATOR_NAME),
                                 leArg));
 
  list modArg = gen_make_list(expression_domain,
                              copy_expression(range_upper(loop_range(curLoop))),
                              copy_expression(bufferSizeExp),
                              NULL);
 
  expression modExp =
    call_to_expression(make_call(entity_intrinsic(C_MODULO_OPERATOR_NAME),
                                 modArg));
 
  list addArg = gen_make_list(expression_domain,
                              modExp,
                              int_to_expression(1),
                              NULL);
 
  expression addExp =
    call_to_expression(make_call(entity_intrinsic(PLUS_C_OPERATOR_NAME),
                                 addArg));
 
  statement trueStat = make_assign_statement(entity_to_expression(transferSize),
                                             addExp);
 
  statement falseStat = make_assign_statement(entity_to_expression(transferSize),
                                              copy_expression(bufferSizeExp));
 
  expression rgUpper = range_upper(loop_range(curLoop));
  intptr_t upVal = -1;
  intptr_t rate = -1;
  expression_integer_value(rgUpper, &upVal);
  expression_integer_value(bufferSizeExp, &rate);
 
  if((upVal != -1) &&
     (rate != -1) &&
     ((upVal+1)%rate == 0))
    {
      free_expression(leExp);
      free_statement(trueStat);
      newStat = falseStat;
    }
  else if((upVal+1) < rate)
    {
      free_expression(leExp);
      free_statement(falseStat);
      newStat = trueStat;
    }
  else
    {
      test t = make_test(leExp, trueStat, falseStat);
 
      newStat = make_statement(entity_empty_label(), 
                               STATEMENT_NUMBER_UNDEFINED,
                               STATEMENT_ORDERING_UNDEFINED,
                               empty_comments,
                               make_instruction(is_instruction_test, t),
                               NIL,NULL,
                               empty_extensions (), make_synchronization_none());
    }
 
  /*statement stepStat = make_loop_step_stat(stat, newOuterInd);
 
  newStat = make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL),
                                           CONS(STATEMENT, newStat, NIL)));
  */
  /*if(!gGenHRE)
    {
      statement indStat = make_init_newInd_stat(stat, newOuterInd);
 
      if(indStat != statement_undefined)
        {
          newStat =
            make_block_statement(gen_nconc(CONS(STATEMENT, newStat, NIL),
                                           CONS(STATEMENT, indStat, NIL)));
        }
    }
*/
  return newStat;
}

References C_LESS_OR_EQUAL_OPERATOR_NAME, C_MODULO_OPERATOR_NAME, call_to_expression(), copy_expression(), DIVIDE_OPERATOR_NAME, empty_comments, empty_extensions(), entity_empty_label(), entity_intrinsic(), entity_to_expression(), expression_domain, expression_integer_value(), free_expression(), free_statement(), gen_make_list(), int_to_expression(), intptr_t, is_instruction_test, loop_range, make_assign_statement(), make_call(), make_instruction(), make_statement(), make_synchronization_none(), make_test(), MULTIPLY_OPERATOR_NAME, NIL, PLUS_C_OPERATOR_NAME, range_upper, statement_loop(), STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, and statement_undefined.

Referenced by make_loop_lStats_HRE(), and make_lStats().

Here is the call graph for this function:

Here is the caller graph for this function:

make_variable_from_name_and_entity()

entity make_variable_from_name_and_entity	(	entity	cloned_variable,
		const char *	base_name,
		statement	stat,
		const char *	module_name
	)

Build and return new entity obtained by cloning variable cloned_variable, with a name obtained by the concatenation of base_name and the statement ordering of statement stat.

If such entity already exist, increment statement ordering to get first free name. We assume then that created entity's name is unique.

Parameters

cloned_variable	loned_variable
base_name	ase_name
stat	tat
module_name	odule_name

Definition at line 325 of file phrase_tools.c.

{
  string variable_name;
  entity returned_variable = NULL;
  int index = statement_ordering(stat);
  //char *buffer;
 
  while (returned_variable == NULL) {
   
    asprintf(&variable_name, base_name, index++);
    returned_variable
      = clone_variable_with_new_name (cloned_variable,
                                      variable_name,
                                      module_name);
  }
 
  return returned_variable;
 
}

References asprintf, clone_variable_with_new_name(), module_name(), statement_ordering, and variable_name().

Referenced by make_begin_variable(), make_end_variable(), make_increment_variable(), and make_index_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

make_wait_ru_module()

entity make_wait_ru_module	(	statement *	,
		int	,
		entity	,
		list
	)

Referenced by controlize_distribution().

Here is the caller graph for this function:

make_wait_step_statement()

statement make_wait_step_statement

(

void

)

Definition at line 113 of file comEngine_generate_HRECode.c.

{
  statement newStat = statement_undefined;
 
  newStat = call_to_statement(
                              make_call(module_name_to_runtime_entity(WAIT_FOR_NEXT_STEP),
                                        NIL));
 
  return newStat;
}

References call_to_statement, make_call(), module_name_to_runtime_entity(), NIL, statement_undefined, and WAIT_FOR_NEXT_STEP.

Referenced by generate_code_call(), generate_stat_from_ref_list_HRE(), generate_stat_from_ref_list_HRE_list(), make_loop_step_stat(), and process_gLoopToSync_HRE().

Here is the call graph for this function:

Here is the caller graph for this function:

phrase_comEngine_distributor()

bool phrase_comEngine_distributor

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 511 of file comEngine_distribute.c.

{
  statement module_stat;
  entity module;
 
  entity dynamic_area = entity_undefined;
 
  // 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: a bit redundant since module is already available
  
  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_COMENGINE_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");
  comEngine_distribute(module_name, 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 comEngine_distribute(), compute_callees(), 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(), 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()

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_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:

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:

phrase_remove_dependences()

bool phrase_remove_dependences

(

const char *

module_name

)

phrase_remove_dependences.c

Get the code of the module.

Parameters

module_name

odule_name

Definition at line 603 of file phrase_remove_dependences.c.

{
  statement module_stat;
 
  /* Get the code of the module. */
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement( (statement)
                                db_get_memory_resource(DBR_CODE, module_name, true) );
  module_stat = get_current_module_statement();
  set_cumulated_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
 
  debug_on("SIMD_LOOP_CONST_ELIM_SCALAR_EXPANSION_DEBUG_LEVEL");
 
  graph dg = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
  gLConflicts = NIL;
 
  MAP(VERTEX, a_vertex, 
  {
    MAP(SUCCESSOR, suc,
    {
      MAP(CONFLICT, c, 
      {
 
        gLConflicts = CONS(CONFLICT, c, gLConflicts);
 
      }, dg_arc_label_conflicts(successor_arc_label(suc)));
 
    }, vertex_successors(a_vertex));
 
  },graph_vertices(dg));
 
  hash_dont_warn_on_redefinition();
 
  // Go through all the statements
  gen_recurse(module_stat, statement_domain,
              gen_true, phrase_remove_dependences_rwt);
  
  hash_warn_on_redefinition();
 
  pips_assert("Statement is consistent after SIMD_SCALAR_EXPANSION", 
              statement_consistent_p(module_stat));
 
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
 
  debug_off();
    
  reset_current_module_entity();
  reset_current_module_statement();
  reset_cumulated_rw_effects();
 
  return true;
}

References CONFLICT, CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dg, dg_arc_label_conflicts, gen_recurse, gen_true(), get_current_module_statement(), gLConflicts, graph_vertices, hash_dont_warn_on_redefinition(), hash_warn_on_redefinition(), MAP, module_name(), module_name_to_entity(), module_reorder(), NIL, phrase_remove_dependences_rwt(), pips_assert, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), statement_consistent_p(), statement_domain, SUCCESSOR, successor_arc_label, VERTEX, and vertex_successors.

Here is the call graph for this function:

print_code_smalltalk()

bool print_code_smalltalk

(

const char *

module_name

)

print_code_smalltalk.c

We first build the future resource file, with a .st

save to file

Parameters

module_name

odule_name

Definition at line 1670 of file print_code_smalltalk.c.

{
  FILE * out;
  string ppt, smalltalkcode, dir, filename;
  entity module;
  statement stat;
 
  /* We first build the future resource file, with a .st */
  smalltalkcode = db_build_file_resource_name(DBR_SMALLTALK_CODE_FILE, module_name, STPRETTY);
  module = module_name_to_entity(module_name);
  dir = db_get_current_workspace_directory();
  filename = strdup(concatenate(dir, "/", smalltalkcode, NULL));
  stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  set_current_module_entity(module);
  set_current_module_statement(stat);
 
  debug_on("SMALLTALK_PRETTYPRINTER_DEBUG_LEVEL");
  pips_debug(1, "Begin SMALLTALK prettyprinter for %s\n", entity_name(module));
  ppt = smalltalk_code_string(module, stat);
  pips_debug(1, "End SMALLTALK prettyprinter for %s\n", entity_name(module));
 
  pips_debug(3, "What i got is \n%s\n", ppt);
 
  /* save to file */
  out = safe_fopen(filename, "w");
  fprintf(out, "/* SMALLTALK pretty print for module %s. */\n%s", module_name, ppt);
  safe_fclose(out, filename);
 
  free(ppt);
  free(dir);
  free(filename);
 
  DB_PUT_FILE_RESOURCE(DBR_SMALLTALK_CODE_FILE, module_name, smalltalkcode);
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_on, entity_name, fprintf(), free(), module, module_name(), module_name_to_entity(), out, pips_debug, s_ppt::ppt, reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), smalltalk_code_string(), STPRETTY, and strdup().

Here is the call graph for this function:

process_gLoopToSync_HRE()

list process_gLoopToSync_HRE	(	statement	stat,
		list	lInStats
	)

Parameters

stat	tat
lInStats	InStats

Definition at line 613 of file comEngine_generate_HRECode.c.

{
  bool loopSync = (intptr_t)hash_get(gLoopToSync, stat);
 
  if(loopSync == (intptr_t)HASH_UNDEFINED_VALUE)
    {
      return lInStats;
    }
 
  statement stepStat = make_wait_step_statement();
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, lInStats);
  lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat, NIL));
  lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
 
  return lStats;
}

References CONS, copy_statement(), gen_nconc(), gLoopToSync, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, make_wait_step_statement(), NIL, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

process_gLoopToSync_proc()

list process_gLoopToSync_proc	(	statement	stat,
		list	lInStats
	)

Parameters

stat	tat
lInStats	InStats

Definition at line 1188 of file comEngine_generate_procCode.c.

{
  bool loopSync = (intptr_t)hash_get(gLoopToSync, stat);
 
  if(loopSync == (intptr_t)HASH_UNDEFINED_VALUE)
    {
      return lInStats;
    }
 
  statement stepStat = make_step_inc_statement(2);
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, lInStats);
  lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat, NIL));
 
  return lInStats;
}

References CONS, gen_nconc(), gLoopToSync, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, make_step_inc_statement(), NIL, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

process_innerStat1_proc()

void process_innerStat1_proc	(	statement	stat,
		entity	oldInd,
		entity	newOuterInd,
		entity	newInnerInd
	)

Parameters

stat	tat
oldInd	ldInd
newOuterInd	ewOuterInd
newInnerInd	ewInnerInd

Definition at line 1057 of file comEngine_generate_procCode.c.

{
  list addArg = gen_make_list(expression_domain,
                              entity_to_expression(newOuterInd),
                              entity_to_expression(newInnerInd),
                              NULL);
 
  expression arg2 = call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                                 addArg));
 
  comEngine_replace_reference_in_stat(stat,
                                      make_reference(oldInd, NIL),
                                      arg2);
}

References call_to_expression(), comEngine_replace_reference_in_stat(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), make_call(), make_reference(), NIL, and PLUS_OPERATOR_NAME.

Referenced by usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

process_replacement_HRE()

void process_replacement_HRE	(	list	lRef,
		expression	buffIndExp,
		statement *	stat
	)

Parameters

lRef	Ref
buffIndExp	uffIndExp
stat	tat

Definition at line 483 of file comEngine_generate_HRECode.c.

{
  replace_array_ref_with_fifos(lRef, buffIndExp, entity_undefined, stat);
}

References entity_undefined, and replace_array_ref_with_fifos().

Referenced by generate_code_call(), generate_code_loop(), generate_code_test_HRE(), make_loopStat1(), process_code_seq(), process_opt_replace(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

process_replacement_HRE_OutRef()

list process_replacement_HRE_OutRef	(	list	lRef,
		list	lStats
	)

Parameters

lRef	Ref
lStats	Stats

Definition at line 493 of file comEngine_generate_HRECode.c.

{
  statement stat = STATEMENT(CAR(lStats));
 
  list savedList = CDR(lStats);
 
  CDR(lStats) = NIL;
  gen_free_list(lStats);
 
  replace_array_ref_with_fifos(lRef, expression_undefined,
                               entity_undefined, &stat);
 
  lStats = gen_nconc(CONS(STATEMENT, stat, NIL), savedList);
 
  return lStats;
}

References CAR, CDR, CONS, entity_undefined, expression_undefined, gen_free_list(), gen_nconc(), NIL, replace_array_ref_with_fifos(), and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_indices_entity_list()

list reference_indices_entity_list

(

reference

ref

)

Parameters

ref

ef

Definition at line 603 of file comEngine_feasability.c.

{
  list lIndRef = NIL;
 
  MAP(EXPRESSION, index,
  {
    list old = lIndRef;
    list new = NIL;
    new = comEngine_expression_to_reference_list(index, new);
 
    lIndRef = gen_concatenate(old, new);
 
    gen_free_list(old);
    gen_free_list(new);
 
  }, reference_indices(ref));
 
  return lIndRef;
}

References comEngine_expression_to_reference_list(), EXPRESSION, gen_concatenate(), gen_free_list(), MAP, NIL, ref, and reference_indices.

Referenced by phrase_check_reference(), and process_ref_list().

Here is the call graph for this function:

Here is the caller graph for this function:

references_for_regions()

list references_for_regions

(

list

l_regions

)

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

Parameters

l_regions

_regions

Definition at line 603 of file phrase_tools.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:

register_scalar_communications()

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

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

Iterate on all regions of the given list

Get the variable type

Look if this variable is already registered

Parameters

ht_communications	t_communications
function	unction
l_regions	_regions

Definition at line 538 of file distribution_context.c.

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

replace_array_ref_with_fifos()

void replace_array_ref_with_fifos	(	list	lRef,
		expression	buffIndExp,
		entity	ind,
		statement *	newStat
	)

Parameters

lRef	Ref
buffIndExp	uffIndExp
ind	nd
newStat	ewStat

Definition at line 286 of file comEngine_generate_HRECode.c.

{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
 
  // Generate the read or write fifo statements
  generate_fifo_stats(lRef, buffIndExp, ind, &lReadStats, &lWriteStats);
 
  // Replace the references by the private variables
  MAP(REFERENCE, curRef,
  {
    //printf("replace_array_ref %d\n", (int)curRef);
    //print_reference(curRef);printf("\n");
 
    entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
    pips_assert("hreBuffEnt != entity_undefined",
                hreBuffEnt != entity_undefined);
 
    reference hreBuffRef = make_reference(hreBuffEnt, NIL);
 
    comEngine_replace_reference_in_stat(*newStat, curRef, reference_to_expression(hreBuffRef));
 
  }, lRef);
 
  lStats = lReadStats;
  if(*newStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, *newStat, NIL));
    }
  lStats = gen_nconc(lStats, lWriteStats);
 
  *newStat = make_block_statement(lStats);
}

References comEngine_replace_reference_in_stat(), CONS, entity_undefined, gen_nconc(), generate_fifo_stats(), get_HRE_buff_ent_from_ref(), make_block_statement(), make_reference(), MAP, NIL, pips_assert, REFERENCE, reference_to_expression(), STATEMENT, and statement_undefined.

Referenced by process_replacement_HRE(), and process_replacement_HRE_OutRef().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_in_sequence_statement_with()

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

Replace statement old_stat by statement new_stat, asserting that this statement is contained in a sequence.

en_insert_after (new_stat, old_stat, stats_list); gen_remove (&stats_list, old_stat);

Parameters

old_stat	ld_stat
new_stat	ew_stat
root_stat	oot_stat

Definition at line 554 of file phrase_tools.c.

{
  statement sequence_statement = sequence_statement_containing (root_stat,
                                                                old_stat);
  list stats_list;
  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);
 
  stats_list = sequence_statements(instruction_sequence(statement_instruction(sequence_statement)));
 
  MAP (STATEMENT, s, {
    ifdebug(7) {
      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);
 
  /*gen_insert_after (new_stat, old_stat, stats_list);
    gen_remove (&stats_list, old_stat);*/
 
  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:

sequence_statement_containing()

statement sequence_statement_containing	(	statement	root_statement,
		statement	searched_stat
	)

Parameters

root_statement	oot_statement
searched_stat	earched_stat

Definition at line 536 of file phrase_tools.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 identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

short_debug_unstructured()

void short_debug_unstructured	(	unstructured	an_unstructured,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured (short version)

Parameters

an_unstructured	n_unstructured
debug_level	ebug_level

Definition at line 213 of file phrase_tools.c.

{
  ifdebug (debug_level) {
 
    list blocs = NIL;
    string entry_as_string, exit_as_string, temp;
    asprintf (&temp, "[%p] ",unstructured_entry(an_unstructured));
    entry_as_string = strdup(temp);
    asprintf (&temp, "[%p] ",unstructured_exit(an_unstructured));
    exit_as_string = strdup(temp);
    pips_debug(debug_level, "%s\n",
               strdup(concatenate("UNSTRUCTURED\n",
                                  "ENTRY: ", entry_as_string, "\n",
                                  "PREVIOUS: ", exit_as_string, "\n",
                                  NULL)));
 
    CONTROL_MAP (current_control, {
      string next_nodes_as_string = "";
      string previous_nodes_as_string = "";
      char *title;
 
      MAP(CONTROL, c, {
        asprintf (&temp, "[%p] ",c);
        previous_nodes_as_string = strdup (concatenate(previous_nodes_as_string,
                                                       (temp),
                                                       NULL));
    free(temp);
      }, control_predecessors(current_control));
 
      MAP(CONTROL, c, {
        asprintf (&temp, "[%p] ",c);
        next_nodes_as_string = strdup (concatenate(next_nodes_as_string,
                                                   (temp),
                                                   NULL));
    free(temp);
      }, control_successors(current_control));
 
      asprintf (&title, "CONTROL: %p\n", current_control);
      pips_debug(debug_level, "%s\n",
                 strdup(concatenate(title,
                                    "NEXT: ", next_nodes_as_string, "\n",
                                    "PREVIOUS: ", previous_nodes_as_string, "\n",
                                    NULL)));
      free(title);
    }, unstructured_entry(an_unstructured), blocs);
  }
}

References asprintf, concatenate(), CONTROL, CONTROL_MAP, control_predecessors, control_successors, free(), ifdebug, MAP, NIL, pips_debug, strdup(), unstructured_entry, and unstructured_exit.

Referenced by flatten_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

spaghettify()

bool spaghettify

(

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 173 of file spaghettify.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(local_name_to_top_level_entity(module_name));
  
  debug_on("SPAGUETTIFY_DEBUG_LEVEL");
 
  /* Now do the job */  
  stat = spaghettify_statement(stat,module_name);
 
  pips_assert("Statement is consistent after SPAGUETTIFY", 
               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, local_name_to_top_level_entity(), module_name(), module_reorder(), pips_assert, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), spaghettify_statement(), and statement_consistent_p().

Here is the call graph for this function:

spaghettify_forloop()

statement spaghettify_forloop	(	statement	stat,
		const char *	module_name
	)

forloop_spaghettify.c

forloop_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 135 of file forloop_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured;  
 
  pips_assert("Statement is FORLOOP in FSM_GENERATION", 
              instruction_tag(statement_instruction(stat)) 
              == is_instruction_forloop);
 
  pips_debug(2, "spaghettify_forloop, module %s\n", module_name);
 
  new_unstructured 
    = make_unstructured_from_forloop 
    (instruction_forloop(statement_instruction(stat)),
     stat,
     module_name);
  
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
  
  statement_instruction(returned_statement) = unstructured_instruction;
 
  return returned_statement;
}

spaghettify_loop()

statement spaghettify_loop	(	statement	stat,
		const char *	module_name
	)

loop_spaghettify.c

loop_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 391 of file loop_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured;  
 
  pips_assert("Statement is LOOP in FSM_GENERATION", 
              instruction_tag(statement_instruction(stat)) 
              == is_instruction_loop);
 
  pips_debug(2, "spaghettify_loop, module %s\n", module_name);   
  new_unstructured = make_unstructured_from_loop (statement_loop(stat), 
                                                  stat,
                                                  module_name);
  
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
  
  statement_instruction(returned_statement) = unstructured_instruction;
 
  return returned_statement;
}

spaghettify_statement()

statement spaghettify_statement	(	statement	stat,
		const char *	module_name
	)

spaghettify.c

spaghettify.c

This phase transforms structured code portions (eg. loops) in unstructured statements.

To add flexibility, the behavior of \texttt{spaghettifier} is controlled by the properties

• DESTRUCTURE_TESTS
• DESTRUCTURE_LOOPS
• DESTRUCTURE_WHILELOOPS
• DESTRUCTURE_FORLOOPS to allow more or less destruction power !

spaghettify > MODULE.code < PROGRAM.entities < MODULE.code This function is recursively called during spaghettization. It takes the statement stat as parameter and return a new spaghettized statement (or the same if nothing has been done). Spaguettization is done:

• on Tests (if property DESTRUCTURE_TESTS set to true)
• on Loops (if property DESTRUCTURE_LOOPS set to true)
• on WhileLoops (if property DESTRUCTURE_WHILELOOPS set to true)
• on ForLoops (if property DESTRUCTURE_FORLOOPS set to true)

Parameters

stat	tat
module_name	odule_name

Definition at line 85 of file spaghettify.c.

{
  // Defaut behaviour is to return parameter statement stat
  statement returned_statement = stat;
  instruction i = statement_instruction(stat);
 
  pips_debug(2,"\nSPAGHETTIFY: Module statement: =====================================\n");
  ifdebug(2) {
    print_statement(stat);
  }
  pips_debug(2,"domain number = %"PRIdPTR"\n", statement_domain_number(stat));
  pips_debug(2,"entity = UNDEFINED\n");
  pips_debug(2,"statement number = %"PRIdPTR"\n", statement_number(stat));
  pips_debug(2,"statement ordering = %"PRIdPTR"\n", statement_ordering(stat));
  if (statement_with_empty_comment_p(stat)) {
    pips_debug(2,"statement comments = EMPTY\n");
  }
  else {
    pips_debug(2,"statement comments = %s\n", statement_comments(stat));
  }
  pips_debug(2,"statement instruction = %s\n", statement_type_as_string(stat));
  switch (instruction_tag(i)) {
  case is_instruction_test: 
    {
      pips_debug(2, "TEST\n");   
    if (get_bool_property("DESTRUCTURE_TESTS")) {
      returned_statement = spaghettify_test (stat, module_name);
    }
      break;
  }
  case is_instruction_sequence: 
    {
      sequence seq = instruction_sequence(i);
      pips_debug(2, "SEQUENCE\n");   
      MAP(STATEMENT, current_stat,
      {
        statement new_stat = spaghettify_statement(current_stat, module_name);
        if (new_stat != NULL) {
          gen_list_patch (sequence_statements(seq), current_stat, new_stat);
        }
      }, sequence_statements(seq));
      break;
    }
  case is_instruction_loop: {
    pips_debug(2, "LOOP\n");   
    if (get_bool_property("DESTRUCTURE_LOOPS")) {
      returned_statement = spaghettify_loop (stat, module_name);
    }
    break;
  }
  case is_instruction_whileloop: {
    pips_debug(2, "WHILELOOP\n");   
    if (get_bool_property("DESTRUCTURE_WHILELOOPS")) {
      returned_statement = spaghettify_whileloop (stat, module_name);
    }
    break;
  }
  case is_instruction_forloop: {
    pips_debug(2, "FORLOOP\n");   
    if (get_bool_property("DESTRUCTURE_FORLOOPS")) {
      returned_statement = spaghettify_forloop (stat, module_name);
    }
    break;
  }
  case is_instruction_call: {
    pips_debug(2, "CALL\n");   
    break;
  }
  case is_instruction_unstructured: {
    pips_debug(2, "UNSTRUCTURED\n");  
    break;
  }
  case is_instruction_goto: {
    pips_debug(2, "GOTO\n");   
    break;
  }
  default:
    pips_debug(2, "UNDEFINED\n");   
    break;
  }
 
  return returned_statement;
}

References gen_list_patch(), get_bool_property(), ifdebug, instruction_sequence, instruction_tag, is_instruction_call, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, MAP, module_name(), pips_debug, print_statement(), sequence_statements, spaghettify_forloop(), spaghettify_loop(), spaghettify_statement(), spaghettify_test(), spaghettify_whileloop(), STATEMENT, statement_comments, statement_domain_number, statement_instruction, statement_number, statement_ordering, statement_type_as_string(), and statement_with_empty_comment_p().

Referenced by make_body_from_forloop(), make_body_from_loop(), make_body_from_whileloop(), make_if_false_from_test(), and make_if_true_from_test().

Here is the call graph for this function:

Here is the caller graph for this function:

spaghettify_test()

statement spaghettify_test	(	statement	stat,
		const char *	module_name
	)

test_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 142 of file test_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured;
 
  pips_assert("Statement is TEST in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_test);
 
  pips_debug(2, "spaghettify_test, module %s\n", module_name);
 
  new_unstructured
    = make_unstructured_from_test
    (instruction_test(statement_instruction(stat)),
     stat,
     module_name);
 
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
 
  statement_instruction(returned_statement) = unstructured_instruction;
  return returned_statement;
}

References instruction_tag, instruction_test, is_instruction_test, is_instruction_unstructured, make_instruction(), make_unstructured_from_test(), module_name(), pips_assert, pips_debug, and statement_instruction.

Referenced by full_spaghettify_statement(), and spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

spaghettify_whileloop()

statement spaghettify_whileloop	(	statement	stat,
		const char *	module_name
	)

whileloop_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 142 of file whileloop_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured; 
 
  pips_assert("Statement is WHILELOOP in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_whileloop);
 
  pips_debug(2, "spaghettify_whileloop, module %s\n", module_name);  
  new_unstructured
    = make_unstructured_from_whileloop
    (instruction_whileloop(statement_instruction(stat)),
     stat,
     module_name);
 
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
 
  statement_instruction(returned_statement) = unstructured_instruction;
 
  return returned_statement;
}

References instruction_tag, instruction_whileloop, is_instruction_unstructured, is_instruction_whileloop, make_instruction(), make_unstructured_from_whileloop(), module_name(), pips_assert, pips_debug, and statement_instruction.

Referenced by full_spaghettify_statement(), and spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_is_contained_in_a_sequence_p()

bool statement_is_contained_in_a_sequence_p	(	statement	root_statement,
		statement	searched_stat
	)

Parameters

root_statement	oot_statement
searched_stat	earched_stat

Definition at line 507 of file phrase_tools.c.

{
  return (sequence_statement_containing (root_statement,
                                         searched_stat) != NULL);
}

References sequence_statement_containing().

Referenced by identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_type_as_string()

string statement_type_as_string

(

statement

stat

)

phrase_tools.c

phrase_tools.c

Parameters

stat

tat

Definition at line 65 of file phrase_tools.c.

{
  instruction i = statement_instruction(stat);
  switch (instruction_tag(i)) {
  case is_instruction_test: {
    return strdup("TEST");  
    break;
  }
  case is_instruction_sequence: {
    return strdup("SEQUENCE");  
    break;
  }
  case is_instruction_loop: {
    return strdup("LOOP");  
    break;
  }
  case is_instruction_whileloop: {
    return strdup("WHILELOOP");  
    break;
  }
  case is_instruction_forloop: {
    return strdup("FORLOOP");  
    break;
  }
  case is_instruction_call: {
    return strdup("CALL");  
    break;
  }
  case is_instruction_unstructured: {
    return strdup("UNSTRUCTURED");  
    break;
  }
  case is_instruction_goto: {
    return strdup("GOTO");  
    break;
  }
  default:
    return strdup("UNDEFINED");  
    break;
  }
}

References instruction_tag, is_instruction_call, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, statement_instruction, and strdup().

Referenced by fsmize_statement(), and spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

store_new_module()

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

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

Parameters

module_name	odule_name
module	odule
module_statement	odule_statement

Definition at line 143 of file phrase_distributor_control_code.c.

{
  string source_file;
  text code;
 
  pips_debug(2, "[BEGIN] store_new_module [%s]\n", module_name);
  ifdebug(2) {
    entity set_entity = get_current_module_entity();
    reset_current_module_entity();
    set_current_module_entity(module);
    pips_debug(2, "Statement for module: ");
    print_statement(module_statement);
    pips_debug(7, "Declarations for module: \n");
    MAP (ENTITY, e, {
      pips_debug(2, "Declared entity %s\n", entity_global_name(e));
    },code_declarations(value_code(entity_initial(module))));
    fprint_environment(stderr, module);
    reset_current_module_entity();
    set_current_module_entity(set_entity);
  }
 
  init_prettyprint(empty_text);
  code = text_module(module, module_statement);
  make_text_resource(module_name,
                     DBR_SOURCE_FILE,
                     ".f",
                     code);
  close_prettyprint();
 
  source_file = db_build_file_resource_name(DBR_SOURCE_FILE, module_name, ".f");
 
  pips_debug(5, "Source file : [%s]\n", source_file);
 
  DB_PUT_NEW_FILE_RESOURCE (DBR_USER_FILE, module_name, source_file);
  DB_PUT_NEW_FILE_RESOURCE (DBR_INITIAL_FILE, module_name, source_file);
 
  init_prettyprint(empty_text);
  make_text_resource(module_name,
                     DBR_INITIAL_FILE,
                     ".f_initial",
                     code);
  close_prettyprint();
 
  pips_debug(2, "[END] store_new_module [%s]\n", module_name);
}

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

string variable_to_string

(

variable

var

)

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

Parameters

var

ar

Definition at line 511 of file distribution_context.c.

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

Variable Documentation

gBufferSize

int gBufferSize

extern

Definition at line 74 of file comEngine_distribute.c.

Referenced by compute_HRE_memory_mapping().

gBufferSizeEnt

expression gBufferSizeEnt

extern

Definition at line 73 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), compute_HRE_memory_mapping(), generate_code(), and generate_code_loop().

gEntToHREFifo

hash_table gEntToHREFifo

extern

Definition at line 83 of file comEngine_distribute.c.

Referenced by alloc_new_slot(), comEngine_distribute_code(), find_or_create_slot(), and generate_ind_fifo_stat2().

gGenHRE

bool gGenHRE

extern

Definition at line 70 of file comEngine_generate_code.c.

Referenced by comEngine_generate_HRECode(), comEngine_generate_procCode(), generate_code_call(), generate_code_function(), generate_code_loop(), generate_code_seq(), make_loop_step_stat(), make_loopStat1(), process_code_seq(), and usual_loop_tiling().

gHREMemory

entity gHREMemory

extern

Definition at line 72 of file comEngine_distribute.c.

gIndToNum

hash_table gIndToNum

extern

Definition at line 80 of file comEngine_distribute.c.

Referenced by alloc_new_slot(), comEngine_distribute_code(), and generate_ind_fifo_stat2().

gIsNewLoop

hash_table gIsNewLoop

extern

Definition at line 86 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), generate_code_loop(), make_seqStat(), and opt_loop_interchange_fill_lists().

gLoopToOpt

hash_table gLoopToOpt

extern

cproto-generated files

comEngine_optimization_function.c

Definition at line 59 of file comEngine_optimization_function.c.

Referenced by comEngine_generate_code(), comEngine_opt_loop_interchange(), fill_gLoopToOpt(), and generate_code_loop().

gLoopToOuterInd

hash_table gLoopToOuterInd

extern

comEngine_generate_code.c

Definition at line 66 of file comEngine_generate_code.c.

Referenced by comEngine_generate_code(), and generate_code_loop().

gLoopToRef

hash_table gLoopToRef

extern

comEngine_distribute.c

Definition at line 66 of file comEngine_distribute.c.

Referenced by attach_ref_to_loop(), comEngine_distribute_code(), generate_code_loop(), and get_supportedRef_proc().

gLoopToSupRef

hash_table gLoopToSupRef

extern

Definition at line 70 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), get_supportedRef_HRE(), get_supportedRef_proc(), and process_ref_lists().

gLoopToSync

hash_table gLoopToSync

extern

Definition at line 69 of file comEngine_distribute.c.

Referenced by check_for_conflict(), comEngine_distribute_code(), process_gLoopToSync_HRE(), and process_gLoopToSync_proc().

gLoopToToggleEnt

hash_table gLoopToToggleEnt

extern

Definition at line 82 of file comEngine_distribute.c.

Referenced by add_toggle_inc_statements(), comEngine_distribute_code(), fill_gLoopToToggleEnt(), generate_code_loop(), make_mmcd_stats_from_ref(), regenerate_toggles(), update_toggle_init_stats_list(), and usual_loop_tiling().

gLoopToUnSupRef

hash_table gLoopToUnSupRef

extern

Definition at line 71 of file comEngine_distribute.c.

Referenced by add_exec_mmcd(), comEngine_distribute_code(), find_or_create_newInd(), get_supportedRef_HRE(), get_supportedRef_proc(), and make_init_newInd_stat().

glToggleInitStats

list glToggleInitStats

extern

Definition at line 89 of file comEngine_generate_code.c.

Referenced by comEngine_generate_code(), regenerate_toggles(), and update_toggle_init_stats_list().

gRefToBuffSize

hash_table gRefToBuffSize

extern

Definition at line 79 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), and update_HRE_mapping_from_list().

gRefToEff

hash_table gRefToEff

extern

Definition at line 68 of file comEngine_distribute.c.

Referenced by attach_ref_to_stat(), comEngine_distribute_code(), create_realFifo_proc(), generate_fifo_stats(), generate_fifo_stats2(), generate_mmcd_stats_from_ref(), generate_stat_from_ref_list_HRE(), and generate_stat_from_ref_list_HRE_list().

gRefToFifo

hash_table gRefToFifo

extern

Definition at line 75 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), compute_fifo_from_ref(), create_realFifo_proc(), fill_gLoopToToggleEnt(), generate_mmcd_stat_from_ref(), and get_toggleEnt_from_ref().

gRefToFifoOff

hash_table gRefToFifoOff

extern

Definition at line 76 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), create_realFifo_proc(), fill_gLoopToToggleEnt(), get_realFifoNum(), and get_toggleEnt_from_ref().

gRefToHREFifo

hash_table gRefToHREFifo

extern

Definition at line 77 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), comEngine_generate_procCode(), compute_fifo_from_ref(), generate_scalar_variables(), get_fifo_from_ref(), and get_realFifoNum().

gRefToHREVar

hash_table gRefToHREVar

extern

comEngine_generate_HRECode.c

Definition at line 68 of file comEngine_generate_HRECode.c.

Referenced by comEngine_generate_HRECode(), generate_code(), generate_scalar_variables(), generate_scalar_variables_from_list(), and get_HRE_buff_ent_from_ref().

gRefToInd

hash_table gRefToInd

extern

Definition at line 81 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), generate_fifo_stat2(), and make_mmcd_stats_from_ref().

gRefToToggle

hash_table gRefToToggle

extern

Definition at line 84 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), generate_fifo_stat2(), make_mmcd_stats_from_ref(), and regenerate_toggles().

gStatToHtOffset

hash_table gStatToHtOffset

extern

Definition at line 78 of file comEngine_distribute.c.

Referenced by comEngine_distribute_code(), do_HRE_memory_mapping_loop(), and generate_code_loop().

gStatToRef

hash_table gStatToRef

extern

Definition at line 67 of file comEngine_distribute.c.

Referenced by attach_ref_to_loop(), check_loop_distribution_feasability(), comEngine_distribute_code(), do_HRE_memory_mapping_stat(), generate_code_call(), generate_code_loop(), generate_code_test_HRE(), generate_code_test_proc(), process_code_seq(), and process_ref_list().

gToggleToInc

hash_table gToggleToInc

extern

Definition at line 85 of file comEngine_distribute.c.

Referenced by add_toggle_inc_statements(), comEngine_distribute_code(), fill_gLoopToToggleEnt(), get_toggleEnt_from_ref(), and regenerate_toggles().