accel-util.h File Reference

#include "transformer.h"
#include "effects.h"

Include dependency graph for accel-util.h:

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

Go to the source code of this file.

Macros
#define	dma_load_p(e)   ((e) == dma_load )
	Add NewGen-like methods: More...
#define	dma_store_p(e)   ((e) == dma_store )
#define	dma_allocate_p(e)   ((e) == dma_allocate )
#define	dma_deallocate_p(e)   ((e) == dma_deallocate )
#define	OUTLINE_PRAGMA   "outline this"
#define	OUTLINE_IGNORE   "outline_ignore"

Enumerations
enum	region_to_dma_switch {   dma_load , dma_store , dma_allocate , dma_deallocate ,   dma_load , dma_store , dma_allocate , dma_deallocate }
	Warning! Do not modify this file that is automatically generated! More...

Functions
bool	group_constants (const string)
	Dependences for accel-util.h. More...
void	region_to_dimensions (effect, transformer, list *, list *, expression *)
	isolate_statement.c More...
list	variable_to_dimensions (effect)
call	dimensions_to_dma (effect, entity, list, list, enum region_to_dma_switch)
	converts dimensions to a dma call from a memory from to another memory to More...
void	do_isolate_statement (statement, const char *, const char *)
	perform statement isolation on statement s that is make sure that all access to variables in s are made either on private variables or on new entities declared on a new memory space. More...
void	isolate_patch_entities (void *, entity, entity, list)
	replace all references on entity old by references on entity new and adds offset offsets to its indices More...
bool	region_to_minimal_dimensions (effect, transformer, list *, list *, bool, expression *)
effect	find_region_on_entity (entity, list)
range	dimension_to_range (dimension)
bool	isolate_statement (const char *)
bool	statement_insertion (const char *)
	statement_insertion.c More...
bool	array_expansion (const char *)
bool	loop_expansion (const char *)
	loop_expansion.c More...
bool	loop_expansion_init (const char *)
	first step of the loop expansion process: create a statement to insert and flag it with a pragma More...
list	outliner_statements_referenced_entities (list)
	outlining.c More...
hash_table	outliner_init (entity, list)
list	outliner_scan (entity, list, statement)
bool	is_entity_in_list (entity, list)
	Checks if an entity is in a list. More...
void	outliner_parameters (entity, statement, list, hash_table, list *, list *)
void	outliner_patch_parameters (list, list, list, list, statement, statement, statement)
	we need to patch parameters , effective parameters and body in C because parameters are passed by copy in function call it's not needed if More...
void	outliner_file (entity, list, statement *)
statement	outliner_call (entity, list, list)
void	remove_from_formal_parameters (list, list *)
void	remove_from_effective_parameters (list, list *)
void	add_induction_var_to_local_declarations (statement *, list)
statement	outliner (const char *, list)
	outline the statements in statements_to_outline into a module named outline_module_name the outlined statements are replaced by a call to the newly generated module statements_to_outline is modified in place to represent that call More...
bool	outline (const string)
	entry point for outline module outlining will be performed using either comment recognition or interactively More...
bool	do_convert_this_array_to_pointer_p (entity)
	array_to_pointer.c More...
size_t	type_dereferencement_depth (type)
bool	linearize_array_generic (const char *)
	linearize accesses to an array, and use pointers if asked to More...
bool	linearize_array (const char *)
	linearize accesses to an array, and use pointers if asked to More...
bool	linearize_array_fortran (const char *)
bool	has_entity_with_same_name (entity, list)
	inlining.c More...
bool	inlining (const char *)
	perform inlining using effects More...
bool	inlining_simple (const char *)
	perform inlining without using effects More...
bool	unfolding (char *)
	perform unfolding using effect More...
bool	unfolding_simple (char *)
	perform unfolding without using effects More...
bool	kernel_load_store (const char *)
	kernels.c More...
bool	kernelize (const string)
	turn a loop flagged with LOOP_LABEL into a kernel (GPU, terapix ...) More...
bool	flag_kernel (const string)
bool	bootstrap_kernels (const string)
void	dump_entity_set (set)
	ikernels.c More...
bool	is_a_kernel (const char *)
bool	ikernel_load_store (char *)
bool	kernel_data_mapping (char *)
bool	wrap_kernel_argument (char *)
	This pass will wrap kernel arguments in a call to a wrapper function. More...
void	normalize_microcode_anotate (void)
	terapixify.c More...
void	terapix_loop_optimizer (statement)
bool	normalize_microcode (char *)
bool	terapix_warmup (const char *)
bool	generate_two_addresses_code (const string)
bool	terapix_remove_divide (const string)
bool	solve_hardware_constraints (const char *)
	constraints.c More...
void	remove_preferences (void *)
	delay.c More...
bool	simd_load_stat_p (statement)
bool	simd_work_stat_p (statement)
bool	simd_store_stat_p (statement)
bool	simd_dma_stat_p (statement)
	This function returns true if the statement is a simd loadsave statement. More...
bool	simd_stat_p (statement)
	This function returns true if the statement is a simd statement. More...
bool	delay_load_communications (char *)
	This phase looks for load or save statements that can be put out of the loop body and move these statements, if possible. More...
bool	delay_load_communications_inter (char *)
bool	delay_load_communications_intra (char *)
bool	delay_store_communications (char *)
bool	delay_store_communications_inter (char *)
bool	delay_store_communications_intra (char *)
bool	delay_communications_inter (const char *)
bool	delay_communications_intra (const char *)
void	gpu_promote_sequential_on_sequence (sequence, loop)
	gpu_promote_sequential.c More...
void	gpu_promote_sequential_on_statement (statement)
bool	gpu_promote_sequential (const char *)
bool	computation_intensity (const char *)
	computation_intensity.c More...
bool	statement_has_omp_parallel_directive_p (statement)
	manage_pragma.c More...
bool	pragma_omp_p (pragma)
	Check that a pragma is an "omp" one. More...
bool	omp_merge_pragma (const char *)
	merge the pragma on the outer loop More...
bool	omp_loop_parallel_threshold_set (const char *)
void	clear_pragma_on_statement (statement)
	Remove all pragma attached to a given statement. More...
bool	clear_pragma (const char *)
	Clear all pragma This should be done on any input with unhandled pragma, we don't what semantic we might break... More...
bool	outline_stmts_between_pragmas_in_sequence (sequence, void *)
bool	pragma_outliner (char *)
bool	ompify_code (const char *)
	generate_pragma.c More...
void	get_variables_to_remove (list, statement, list *)
	misc.c More...

Macro Definition Documentation

dma_allocate_p

#define dma_allocate_p

(

e

)

((e) == dma_allocate )

Definition at line 14 of file accel-util.h.

dma_deallocate_p

#define dma_deallocate_p

(

e

)

((e) == dma_deallocate )

Definition at line 15 of file accel-util.h.

dma_load_p

#define dma_load_p

(

e

)

((e) == dma_load )

Add NewGen-like methods:

Definition at line 12 of file accel-util.h.

dma_store_p

#define dma_store_p

(

e

)

((e) == dma_store )

Definition at line 13 of file accel-util.h.

OUTLINE_IGNORE

#define OUTLINE_IGNORE   "outline_ignore"

Definition at line 18 of file accel-util.h.

OUTLINE_PRAGMA

#define OUTLINE_PRAGMA   "outline this"

Definition at line 17 of file accel-util.h.

Enumeration Type Documentation

region_to_dma_switch

enum region_to_dma_switch

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

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

Enumerator
dma_load
dma_store
dma_allocate
dma_deallocate
dma_load
dma_store
dma_allocate
dma_deallocate

Definition at line 10 of file accel-util.h.

{ dma_load, dma_store, dma_allocate, dma_deallocate };

Function Documentation

add_induction_var_to_local_declarations()

void add_induction_var_to_local_declarations	(	statement *	new_body,
		list	induction_var
	)

Parameters

new_body	ew_body
induction_var	nduction_var

Definition at line 1307 of file outlining.c.

                                                                                      {
  push_generated_variable_commenter(outlining_variable_commenter);
  FOREACH(entity, ent, induction_var) {
    *new_body = add_declaration_statement(*new_body, ent);
  }
  pop_generated_variable_commenter();
}

References add_declaration_statement(), FOREACH, outlining_variable_commenter(), pop_generated_variable_commenter(), and push_generated_variable_commenter().

Referenced by outliner_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

array_expansion()

bool array_expansion

(

const char *

module_name

)

init

do

validate

Parameters

module_name

odule_name

Definition at line 395 of file statement_insertion.c.

{
    /* init */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings(get_current_module_entity());
    set_precondition_map( (statement_mapping) db_get_memory_resource(DBR_PRECONDITIONS, module_name, true) );
    debug_on("ARRAY_EXPANSION_DEBUG_LEVEL");
 
    /* do */
    hash_table expanded = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
    gen_context_recurse(get_current_module_statement(),expanded,
            statement_domain,do_array_expansion,do_array_expansion_aux);
    hash_table_free(expanded);
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    debug_off();
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_precondition_map();
    free_value_mappings();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_array_expansion(), do_array_expansion_aux(), expanded, free_value_mappings(), gen_context_recurse, get_current_module_entity(), get_current_module_statement(), HASH_DEFAULT_SIZE, hash_pointer, hash_table_free(), hash_table_make(), module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_precondition_map(), set_proper_rw_effects(), and statement_domain.

Here is the call graph for this function:

bootstrap_kernels()

bool bootstrap_kernels

(

const

string

)

Parameters

string

odule_name

Definition at line 297 of file kernels.c.

{
  if (db_resource_p(DBR_KERNELS, ""))
    pips_internal_error("kernels already initialized for %s", module_name);
  callees kernels=make_callees(NIL);
  DB_PUT_MEMORY_RESOURCE(DBR_KERNELS,"",kernels);
  return true;
}

References DB_PUT_MEMORY_RESOURCE, db_resource_p(), make_callees(), module_name(), NIL, and pips_internal_error.

Here is the call graph for this function:

clear_pragma()

bool clear_pragma

(

const char *

module_name

)

Clear all pragma This should be done on any input with unhandled pragma, we don't what semantic we might break...

Put the new CODE ressource into PIPS:

Parameters

module_name

odule_name

Definition at line 403 of file manage_pragma.c.

                                           {
  debug_on("CLEAR_PRAGMA_DEBUG_LEVEL");
  statement mod_stmt = statement_undefined;
  // Get the code and tell PIPS_DBM we do want to modify it
  mod_stmt = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  // Set the current module entity and the current module statement that are
  // required to have many things working in PIPS
  set_current_module_statement(mod_stmt);
  set_current_module_entity(module_name_to_entity(module_name));
 
  // Add the parallel threshold to all the omp for pragmas
  gen_recurse(mod_stmt, statement_domain, gen_true, clear_pragma_on_statement);
 
  /* Put the new CODE ressource into PIPS: */
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, mod_stmt);
 
  // There is no longer a current module:
  reset_current_module_statement();
  reset_current_module_entity();
 
  pips_debug(2, "done for %s\n", module_name);
  debug_off();
 
  return true;
}

References clear_pragma_on_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), module_name(), module_name_to_entity(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_domain, and statement_undefined.

Here is the call graph for this function:

clear_pragma_on_statement()

void clear_pragma_on_statement

(

statement

s

)

Remove all pragma attached to a given statement.

Definition at line 388 of file manage_pragma.c.

                                            {
  list exs = extensions_extension(statement_extensions(s));
  list keep_exs = NIL;
  FOREACH(EXTENSION, ex, exs) {
    if(!extension_pragma_p(ex))
      keep_exs = CONS(EXTENSION,ex,keep_exs);
  }
  extensions_extension(statement_extensions(s)) = keep_exs;
  gen_free_list(exs);
}

References CONS, EXTENSION, extension_pragma_p, extensions_extension, FOREACH, gen_free_list(), NIL, and statement_extensions.

Referenced by clear_pragma(), is_SCOP_rich(), and outline_stmts_between_pragmas_in_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

computation_intensity()

bool computation_intensity

(

const char *

module_name

)

computation_intensity.c

computation_intensity.c

The computation intensity is derived from the complexity and the memory footprint. It assumes the cost model: execution_time = startup_overhead + memory_footprint / bandwidth + complexity / frequency

init stuff

do it now !

validate changes

reset

Parameters

module_name

odule_name

Definition at line 123 of file computation_intensity.c.

                                                    {
    /* init stuff */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_complexity_map( (statement_mapping) db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
 
    computation_intensity_param p;
    init_computation_intensity_param(&p);
 
    /* do it now ! */
    gen_context_recurse(get_current_module_statement(), &p,
            statement_domain, do_computation_intensity, gen_null2);
 
    /* validate changes */
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /* reset */
    reset_current_module_entity();
    reset_current_module_statement();
    reset_complexity_map();
    reset_cumulated_rw_effects();
 
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_computation_intensity(), gen_context_recurse, gen_null2(), get_current_module_statement(), init_computation_intensity_param(), module_name(), module_name_to_entity(), reset_complexity_map(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_complexity_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

delay_communications_inter()

bool delay_communications_inter

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 970 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = true;
  return delay_communications(module_name);
}

References delay_communications(), delay_communications_interprocedurally_p, and module_name().

Here is the call graph for this function:

delay_communications_intra()

bool delay_communications_intra

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 974 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = false;
  return delay_communications(module_name);
}

References delay_communications(), delay_communications_interprocedurally_p, and module_name().

Here is the call graph for this function:

delay_load_communications()

bool delay_load_communications

(

char *

module_name

)

This phase looks for load or save statements that can be put out of the loop body and move these statements, if possible.

Get the code of the module.

Go through all the statements

then a backward translation

propagate inter procedurally , except if we have no caller

clean badly generated sequences

Parameters

module_name

odule_name

Definition at line 607 of file delay.c.

{
    /* Get the code of the module. */
    entity module = module_name_to_entity(module_name);
    statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
    set_ordering_to_statement(module_stat);
    set_current_module_entity( module);
    set_current_module_statement( module_stat);
    set_proper_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true)
    );
    remove_preferences(get_proper_rw_effects());
    set_cumulated_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true)
    );
 
 
    debug_on("DELAY_COMMUNICATIONS_DEBUG_LEVEL");
    delay_communications_init();
    dependence_graph = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
    /* Go through all the statements */
    context c = { true, NIL, true, false , NULL, NULL };
 
    /* then a backward translation */
    delay_communications_statement(module_stat,&c,NULL);
 
    /* propagate inter procedurally , except if we have no caller*/
    if(delay_communications_interprocedurally_p)
        delay_communications_interprocedurally(&c);
    else
        delay_communications_intraprocedurally(module_stat,&c);
 
    if(c.need_flatten)
        statement_flatten_declarations(module,module_stat);
 
    /* clean badly generated sequences */
    clean_up_sequences(module_stat);
 
    delay_communications_reset();
 
 
    pips_assert("Statement is consistent\n" , statement_consistent_p(module_stat));
 
    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));
 
    debug_off();
 
    reset_current_module_entity();
    reset_ordering_to_statement();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
 
    return c.result;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, delay_communications_init(), delay_communications_interprocedurally(), delay_communications_interprocedurally_p, delay_communications_intraprocedurally(), delay_communications_reset(), delay_communications_statement(), dependence_graph, false, get_proper_rw_effects(), module, module_name(), module_name_to_entity(), module_reorder(), context::need_flatten, NIL, pips_assert, remove_preferences(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), context::result, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), statement_consistent_p(), and statement_flatten_declarations().

Referenced by delay_load_communications_inter(), and delay_load_communications_intra().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_load_communications_inter()

bool delay_load_communications_inter

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 665 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = true;
  return delay_load_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_load_communications(), and module_name().

Here is the call graph for this function:

delay_load_communications_intra()

bool delay_load_communications_intra

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 669 of file delay.c.

                                                         {
  delay_communications_interprocedurally_p = false;
  return delay_load_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_load_communications(), and module_name().

Here is the call graph for this function:

delay_store_communications()

bool delay_store_communications

(

char *

module_name

)

Get the code of the module.

Go through all the statements

a first forward translation

propagate inter procedurally , except if we have no caller

clean badly generated sequences

Parameters

module_name

odule_name

Definition at line 674 of file delay.c.

{
    /* Get the code of the module. */
    entity module = module_name_to_entity(module_name);
    statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
    set_ordering_to_statement(module_stat);
    set_current_module_entity( module);
    set_current_module_statement( module_stat);
    set_proper_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true)
    );
    remove_preferences(get_proper_rw_effects());
    set_cumulated_rw_effects(
            (statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true)
    );
    delay_communications_init();
 
    dependence_graph = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
    debug_on("DELAY_COMMUNICATIONS_DEBUG_LEVEL");
 
 
 
    /* Go through all the statements */
    context c = { true, NIL, false, false, NULL, NULL };
 
    /* a first forward translation */
    delay_communications_statement(module_stat,&c,NULL);
 
    /* propagate inter procedurally , except if we have no caller*/
    if(delay_communications_interprocedurally_p)
        delay_communications_interprocedurally(&c);
    else
        delay_communications_intraprocedurally(module_stat,&c);
 
    if(c.need_flatten)
        statement_flatten_declarations(module,module_stat);
 
    /* clean badly generated sequences */
    clean_up_sequences(module_stat);
 
    delay_communications_reset();
 
    pips_assert("Statement is consistent\n" , statement_consistent_p(module_stat));
 
    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));
 
    debug_off();
 
    reset_current_module_entity();
    reset_ordering_to_statement();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
 
    return c.result;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, delay_communications_init(), delay_communications_interprocedurally(), delay_communications_interprocedurally_p, delay_communications_intraprocedurally(), delay_communications_reset(), delay_communications_statement(), dependence_graph, get_proper_rw_effects(), module, module_name(), module_name_to_entity(), module_reorder(), context::need_flatten, NIL, pips_assert, remove_preferences(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), context::result, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), statement_consistent_p(), and statement_flatten_declarations().

Referenced by delay_store_communications_inter(), and delay_store_communications_intra().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_store_communications_inter()

bool delay_store_communications_inter

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 733 of file delay.c.

                                                          {
  delay_communications_interprocedurally_p = true;
  return delay_store_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_store_communications(), and module_name().

Here is the call graph for this function:

delay_store_communications_intra()

bool delay_store_communications_intra

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 737 of file delay.c.

                                                          {
  delay_communications_interprocedurally_p = false;
  return delay_store_communications(module_name);
}

References delay_communications_interprocedurally_p, delay_store_communications(), and module_name().

Here is the call graph for this function:

dimension_to_range()

range dimension_to_range

(

dimension

d

)

Returns

a range suitable for iteration over all the elements of dimension d

Definition at line 1336 of file isolate_statement.c.

{
    return make_range(
            copy_expression(dimension_lower(d)),
            copy_expression(dimension_upper(d)),
            int_to_expression(1));
}

References copy_expression(), dimension_lower, dimension_upper, int_to_expression(), and make_range().

Referenced by do_group_constants_terapix().

Here is the call graph for this function:

Here is the caller graph for this function:

dimensions_to_dma()

call dimensions_to_dma	(	effect	reg_from,
		entity	to,
		list	ld,
		list	lo,
		enum region_to_dma_switch	m
	)

converts dimensions to a dma call from a memory from to another memory to

Parameters

from	expression giving the adress of the input memory
to	expression giving the adress of the output memory
ld	list of dimensions to analyze
m	kind of call to generate

Returns

Scalar detection:

Need the address for the allocator to modify the pointer itself:

Generate a "void **" type:

dest = "(void **) &to"

Except for the deallocation or if we have a scalar and then we have already created a pointer to it, the original array is referenced through pointer dereferencing:

sizeof(element)*number elements of the array:

Generate communication functions:

Build the sizes of the array block to transfer:

f expressions

Build the sizes of the array with element to transfer:

of expressions

Build the offsets of the array block to transfer:

of expressions

Use a special transfert function for scalars instead of reusing the 1D function. It may useful for example if it is implemented as a FIFO at the hardware level:

Generate host and accel adresses:

Output parameters in an order compatible with some C99 implementation of the runtime: size and block size first, so that some arguments can be defined with them:

Insert offset:

Insert the block size to transfert:

Insert the array sizes:

Insert the element size expression:

Parameters

reg_from	eg_from
to	o
ld	f dimensions
lo	f offsets

Definition at line 379 of file isolate_statement.c.

{
    entity from = reference_variable(region_any_reference(reg_from));
    expression dest;
    list args = NIL;
    const char* function_name = get_dma_name(m,get_dma_dimension(reg_from));
 
    entity mcpy = module_name_to_entity(function_name);
    if (entity_undefined_p(mcpy)) {
        mcpy=make_empty_subroutine(function_name,copy_language(module_language(get_current_module_entity())));
        pips_user_warning("Cannot find \"%s\" method. Are you sure you have set\n"
                "KERNEL_LOAD_STORE_..._FUNCTION "
                "to a defined entity and added the correct .c file?\n",function_name);
    }
    else if (!fortran_module_p(get_current_module_entity())) {
        AddEntityToModuleCompilationUnit(mcpy,get_current_module_entity());
    } else
        AddEntityToModule(mcpy,get_current_module_entity());
 
    /* Scalar detection: */
    bool scalar_entity = entity_scalar_p(from);
 
    if (dma_allocate_p(m)) {
        /* Need the address for the allocator to modify the pointer itself: */
        dest = MakeUnaryCall(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),entity_to_expression(to));
        /* Generate a "void **" type: */
        type voidpp = make_type_variable(
                make_variable(
                    make_basic_pointer(
                        make_type_variable(
                            make_variable(
                                make_basic_pointer(
                                    make_type_void(NIL)
                                    ),
                                NIL,NIL
                                )
                            )
                        ),
                    NIL,NIL
                    )
                );
        /* dest = "(void **) &to" */
        dest = make_expression(
                make_syntax_cast(
                    make_cast(voidpp,dest)
                    ),
                normalized_undefined);
    }
    else if (!dma_deallocate_p(m) && !scalar_entity)
        /* Except for the deallocation or if we have a scalar and then we have
           already created a pointer to it, the original array is referenced
           through pointer dereferencing: */
        dest = MakeUnaryCall(entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
                entity_to_expression(to));
    else
        dest=entity_to_expression(to);
 
 
    switch(m) {
        case dma_deallocate:
            args = make_expression_list(dest);
            break;
        case dma_allocate:
            {
                expression sizeof_exp = get_sizeofexpression_for_region(reg_from);
 
                /* sizeof(element)*number elements of the array: */
                expression transfer_size = SizeOfDimensions(ld);
                transfer_size=MakeBinaryCall(
                        entity_intrinsic(MULTIPLY_OPERATOR_NAME),
                        sizeof_exp,
                        transfer_size);
 
                args = make_expression_list(dest, transfer_size);
            } break;
        case dma_load:
        case dma_store:
            /* Generate communication functions: */
            {
                //if(!scalar_entity) {
                /* Build the sizes of the array block to transfer: */
                list /*of expressions*/ transfer_sizes = NIL;
                FOREACH(DIMENSION,d,ld) {
                    expression transfer_size=
                        SizeOfDimension(d);
                    transfer_sizes=CONS(EXPRESSION,transfer_size,transfer_sizes);
                }
                transfer_sizes=gen_nreverse(transfer_sizes);
 
                /* Build the sizes of the array with element to transfer: */
                list/* of expressions*/ from_dims = NIL;
                list vardims = variable_to_dimensions(reg_from);
                FOREACH(DIMENSION,d, vardims) {
                    from_dims=CONS(EXPRESSION,SizeOfDimension(d),from_dims);
                }
                gen_full_free_list(vardims);
                from_dims=gen_nreverse(from_dims);
 
                /* Build the offsets of the array block to transfer: */
                list/* of expressions*/ offsets = NIL;
                FOREACH(EXPRESSION,e,lo)
                    offsets=CONS(EXPRESSION,e,offsets);
                offsets=gen_nreverse(offsets);
                /* Use a special transfert function for scalars instead of reusing
                   the 1D function. It may useful for example if it is implemented
                   as a FIFO at the hardware level: */
                //} else {
                //    /* If we have a scalar variable to transfert, generate
                //       synthetic transfer parameters: */
                //    /* 1 element to transfert */
                //    transfer_sizes = make_expression_list(int_to_expression(1));
                //    /* 1 dimension */
                //    from_dims = make_expression_list(int_to_expression(1));
                //    /* At the begining of the « array »: */
                //    offsets = make_expression_list(int_to_expression(0));
                //  }
 
                expression source = region_to_address(reg_from);
                /* Generate host and accel adresses: */
                args = CONS(EXPRESSION,source,CONS(EXPRESSION,dest,NIL));
                //if(dma_load_p(m))
                //    args=gen_nreverse(args);
                /* Output parameters in an order compatible with some C99
                   implementation of the runtime: size and block size first, so
                   that some arguments can be defined with them: */
                /* Insert offset: */
                args = gen_append(offsets, args);
                /* Insert the block size to transfert: */
                args = gen_append(transfer_sizes, args);
                /* Insert the array sizes: */
                args = gen_append(from_dims, args);
                /* Insert the element size expression: */
                expression sizeof_exp = get_sizeofexpression_for_region(reg_from);
                args = CONS(EXPRESSION,
                        sizeof_exp,
                        args);
            } break;
        default:
            pips_internal_error("should not happen");
    }
    return make_call(mcpy, args);
}

References AddEntityToModule(), AddEntityToModuleCompilationUnit(), ADDRESS_OF_OPERATOR_NAME, CONS, copy_language(), DEREFERENCING_OPERATOR_NAME, DIMENSION, dma_allocate, dma_allocate_p, dma_deallocate, dma_deallocate_p, dma_load, dma_store, entity_intrinsic(), entity_scalar_p(), entity_to_expression(), entity_undefined_p, EXPRESSION, FOREACH, fortran_module_p(), gen_append(), gen_full_free_list(), gen_nreverse(), get_current_module_entity(), get_dma_dimension(), get_dma_name(), get_sizeofexpression_for_region(), make_basic_pointer(), make_call(), make_cast(), make_empty_subroutine(), make_expression(), make_expression_list, make_syntax_cast(), make_type_variable(), make_type_void(), make_variable(), MakeBinaryCall(), MakeUnaryCall(), module_language, module_name_to_entity(), MULTIPLY_OPERATOR_NAME, NIL, normalized_undefined, pips_internal_error, pips_user_warning, reference_variable, region_any_reference, region_to_address(), SizeOfDimension(), SizeOfDimensions(), and variable_to_dimensions().

Referenced by effects_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

do_convert_this_array_to_pointer_p()

bool do_convert_this_array_to_pointer_p

(

entity

e

)

array_to_pointer.c

Definition at line 68 of file array_to_pointer.c.

                                                  {
  if(get_bool_property("LINEARIZE_ARRAY_USE_POINTERS")) {
    if(get_bool_property("LINEARIZE_ARRAY_SKIP_STATIC_LENGTH_ARRAYS") && !entity_variable_length_array_p(e))
      return false;
    value v =entity_initial(e);
    if ( !value_undefined_p(v) && value_expression_p(v) && !expression_brace_p(value_expression(v) ) ) 
        return true;
    if( get_bool_property("LINEARIZE_ARRAY_SKIP_LOCAL_ARRAYS") && !entity_formal_p(e) ) 
      return false;
    return true;
  }
  return false;
}

References entity_formal_p(), entity_initial, entity_variable_length_array_p(), expression_brace_p(), get_bool_property(), value_expression, value_expression_p, and value_undefined_p.

Referenced by do_array_to_pointer(), do_array_to_pointer_walk_expression(), and do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_isolate_statement()

void do_isolate_statement	(	statement	s,
		const char *	prefix,
		const char *	suffix
	)

perform statement isolation on statement s that is make sure that all access to variables in s are made either on private variables or on new entities declared on a new memory space.

The prefix is used as a prefix to new entities' name.

this hash table holds an entity to (entity + tag ) binding

Add the calls now if needed, in the correct order:

guard the whole block by according conditions

prends ton couteau suisse et viens jouer avec moi dans pips

Parameters

prefix	refix
suffix	uffix

Definition at line 1018 of file isolate_statement.c.

                                                                               {
    bool fine_grain_analysis = true;
    statement allocates, loads, stores, deallocates;
    /* this hash table holds an entity to (entity + tag ) binding */
    hash_table e2e ;
    if(!do_isolate_statement_preconditions_satisified_p(s)) {
        pips_user_warning("isolated statement has callees, transfers will be approximated\n");
        fine_grain_analysis = false; // FIXME : This could be true most of the time, especially in Par4All !
    }
    e2e = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
    expression condition = expression_undefined;
    allocates = effects_to_dma(s,dma_allocate,e2e,&condition,
            fine_grain_analysis,prefix,suffix);
    loads = effects_to_dma(s,dma_load,e2e,NULL,fine_grain_analysis,prefix,
            suffix);
    stores = effects_to_dma(s,dma_store,e2e,NULL,fine_grain_analysis,prefix,
            suffix);
    deallocates = effects_to_dma(s,dma_deallocate,e2e,NULL,fine_grain_analysis,
            prefix,suffix);
    HASH_MAP(k,v,free(v),e2e);
    hash_table_free(e2e);
 
    /* Add the calls now if needed, in the correct order: */
    if (loads != statement_undefined)
        insert_statement(s, loads,true);
    if (stores != statement_undefined)
        insert_statement(s, stores,false);
    if (deallocates != statement_undefined)
        insert_statement(s, deallocates,false);
    if (allocates != statement_undefined)
        insert_statement(s, allocates,true);
    /* guard the whole block by according conditions */
    if(!expression_undefined_p(condition)) {
 
        /* prends ton couteau suisse et viens jouer avec moi dans pips */
        pips_assert("statement is a block",statement_block_p(s));
        for(list prev=NIL,iter=statement_block(s);!ENDP(iter);POP(iter)) {
            if(declaration_statement_p(STATEMENT(CAR(iter)))) prev=iter;
            else {
                pips_assert("there should be at least one declaration inserted by isolate_statement\n",!ENDP(prev));
                statement cond = 
                    instruction_to_statement(
                            make_instruction_test(
                                make_test(
                                    condition,
                                    make_block_statement(iter),
                                    make_empty_statement()
                                    )
                                )
                            );
                CDR(prev)=CONS(STATEMENT,cond,NIL);
                break;
            }
        }
    }
}

References CAR, CDR, CONS, declaration_statement_p(), dma_allocate, dma_deallocate, dma_load, dma_store, do_isolate_statement_preconditions_satisified_p(), effects_to_dma(), ENDP, expression_undefined, expression_undefined_p, free(), HASH_DEFAULT_SIZE, HASH_MAP, hash_pointer, hash_table_free(), hash_table_make(), insert_statement(), instruction_to_statement(), make_block_statement(), make_empty_statement, make_instruction_test(), make_test(), NIL, pips_assert, pips_user_warning, POP, prefix, STATEMENT, statement_block(), statement_block_p, and statement_undefined.

Referenced by isolate_statement(), and kernel_load_store_generator().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_entity_set()

void dump_entity_set

(

set

s

)

ikernels.c

Definition at line 209 of file ikernels.c.

                            {
  SET_FOREACH(entity, e, s) {
    fprintf(stderr,"%s,",entity_name(e));
  }
  fprintf(stderr,"\n");
}

References entity_name, fprintf(), and SET_FOREACH.

Here is the call graph for this function:

find_region_on_entity()

effect find_region_on_entity	(	entity	e,
		list	regions
	)

Returns

region from regions on entity e

Parameters

regions

egions

Definition at line 1325 of file isolate_statement.c.

{
    FOREACH(REGION,r,regions)
        if(same_entity_p(e,reference_variable(region_any_reference(r)))) return r;
    return region_undefined;
}

References FOREACH, reference_variable, REGION, region_any_reference, region_undefined, and same_entity_p().

Referenced by do_solve_hardware_constraints_on_nb_proc(), and do_solve_hardware_constraints_on_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

flag_kernel()

bool flag_kernel

(

const

string

)

Parameters

string

odule_name

Definition at line 287 of file kernels.c.

{
  if (!db_resource_p(DBR_KERNELS, ""))
    pips_internal_error("kernels not initialized for %s", module_name);
  callees kernels=(callees)db_get_memory_resource(DBR_KERNELS,"",true);
  callees_callees(kernels)= CONS(STRING,strdup(module_name),callees_callees(kernels));
  DB_PUT_MEMORY_RESOURCE(DBR_KERNELS,"",kernels);
  return true;
}

References callees_callees, CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, db_resource_p(), module_name(), pips_internal_error, strdup(), and STRING.

Here is the call graph for this function:

generate_two_addresses_code()

bool generate_two_addresses_code

(

const

string

)

prelude

validate

ostlude

Parameters

string

odule_name

Definition at line 991 of file terapixify.c.

{
    /* prelude */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS,module_name,true));
    set_conflict_testing_properties();
    gen_recurse(get_current_module_statement(),statement_domain,gen_true,two_addresses_code_generator);
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /*postlude*/
    reset_cumulated_rw_effects();
    reset_current_module_entity();
    reset_current_module_statement();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, gen_recurse, gen_true(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_conflict_testing_properties(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), statement_domain, and two_addresses_code_generator().

Here is the call graph for this function:

get_variables_to_remove()

void get_variables_to_remove	(	list	ref_ent,
		statement	s,
		list *	l
	)

misc.c

misc.c

Required by R-Stream. Depending on the activated option, only loop indexes or both loop indexes and written scalar variables are put into the list.

Parameters

ref_ent

ef_ent

Definition at line 58 of file misc.c.

                                                                 {
  instruction instTop = statement_instruction(s);
  switch(instruction_tag(instTop)) {
  case is_instruction_sequence :
    {
      list stmts = sequence_statements(instruction_sequence(instTop));
      FOREACH(statement, stmt, stmts) {
        list enclosing_loops = load_statement_enclosing_loops(s);
        if (!ENDP(enclosing_loops) && !statement_loop_p(stmt)) {
          FOREACH(entity, e, ref_ent) {
            if (get_bool_property("OUTLINE_REMOVE_VARIABLE_RSTREAM_IMAGE")) {
              bool write_p = find_write_effect_on_entity(stmt, e);
              if (index_of_a_loop_p((Variable)e, enclosing_loops) || (write_p && !entity_array_p(e))) {
                *l = gen_once(e,*l);
              }
            }
            else if (get_bool_property("OUTLINE_REMOVE_VARIABLE_RSTREAM_SCOP")) {
              if (index_of_a_loop_p((Variable)e, enclosing_loops)) {
                *l = gen_once(e,*l);
              }
            }
          }
        }
        instruction inst = statement_instruction(stmt);
        switch(instruction_tag(inst)) {
        case is_instruction_loop :
          get_variables_to_remove(ref_ent, loop_body(statement_loop(stmt)), l);
          break;
        case is_instruction_whileloop :
          get_variables_to_remove(ref_ent, whileloop_body(statement_whileloop(stmt)), l);
          break;
        case is_instruction_test :
          get_variables_to_remove(ref_ent, test_true(instruction_test(inst)), l);
          get_variables_to_remove(ref_ent, test_false(instruction_test(inst)), l);
          break;
        default :
          break;
        }
        
      }
    }
    break;
  case is_instruction_loop :
    {
      get_variables_to_remove(ref_ent, loop_body(instruction_loop(instTop)), l);
    }
    break;
  case is_instruction_whileloop :
    {
      get_variables_to_remove(ref_ent, whileloop_body(instruction_whileloop(instTop)), l);
    }
    break;
  case is_instruction_test :
    {
      get_variables_to_remove(ref_ent, test_true(instruction_test(instTop)), l);
      get_variables_to_remove(ref_ent, test_false(instruction_test(instTop)), l);
    }
    break;
  default :
    {
      list enclosing_loops = load_statement_enclosing_loops(s);
      if (!ENDP(enclosing_loops)) {
        FOREACH(entity, e, ref_ent) {
          if (get_bool_property("OUTLINE_REMOVE_VARIABLE_RSTREAM_IMAGE")) {
            bool write_p = find_write_effect_on_entity(s, e);
            if (index_of_a_loop_p((Variable)e, enclosing_loops) || (write_p && !entity_array_p(e))) {
              *l = gen_once(e,*l);
            }
          }
          else if (get_bool_property("OUTLINE_REMOVE_VARIABLE_RSTREAM_SCOP")) {
            if (index_of_a_loop_p((Variable)e, enclosing_loops)) {
              *l = gen_once(e,*l);
            }
          }
        }
      }
    }
    break;
  }
}

References ENDP, entity_array_p(), find_write_effect_on_entity(), FOREACH, gen_once(), get_bool_property(), get_variables_to_remove(), index_of_a_loop_p(), instruction_loop, instruction_sequence, instruction_tag, instruction_test, instruction_whileloop, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_whileloop, load_statement_enclosing_loops(), loop_body, sequence_statements, statement_instruction, statement_loop(), statement_loop_p(), statement_whileloop(), test_false, test_true, and whileloop_body.

Referenced by get_variables_to_remove(), and outliner_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

gpu_promote_sequential()

bool gpu_promote_sequential

(

const char *

module_name

)

Initialize set for each statement

Parameters

module_name

odule_name

Definition at line 143 of file gpu_promote_sequential.c.

                                                     {
  statement module_stat = (statement)db_get_memory_resource(DBR_CODE,
                                                            module_name,
                                                            true);
  set_current_module_statement(module_stat);
  set_current_module_entity(local_name_to_top_level_entity(module_name));
 
  debug_on("GPU_PROMOTE_SEQUENTIAL_DEBUG_LEVEL");
 
  /* Initialize set for each statement */
  gpu_promote_sequential_on_statement(module_stat);
 
  debug_off();
 
  module_reorder(module_stat);
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,
      module_name,
      module_stat);
 
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
 
 
 
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gpu_promote_sequential_on_statement(), local_name_to_top_level_entity(), module_name(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), and set_current_module_statement().

Here is the call graph for this function:

gpu_promote_sequential_on_sequence()

void gpu_promote_sequential_on_sequence	(	sequence	seq,
		loop	l
	)

gpu_promote_sequential.c

gpu_promote_sequential.c

The heuristic that trigger the promotion is quite simple at that time, all sequential code is promoted if a parallel loop is present in the sequence

Parameters

seq	is the sequence on which to operate @loop l is an optionnal param that give the enclosing loop

Parameters

seq

eq

Definition at line 83 of file gpu_promote_sequential.c.

                                                              {
  list stmts = sequence_statements(seq);
 
  // Try to find a parallel loop in the sequence
  bool found_parallel_loop_p = false;
  FOREACH(statement,s,stmts) {
    if(parallel_loop_statement_p(s)) {
      found_parallel_loop_p = true;
      break;
    }
  }
 
  if(found_parallel_loop_p) {
    list new_stmts = NIL;
    list promoted_stmts = NIL;
    FOREACH(statement,s,stmts) {
      if(!parallel_loop_statement_p(s)) {
        if(!empty_statement_or_continue_p(s)) {
          ifdebug(2) {
            pips_debug(2,"Promote statement :");
            print_statement(s);
          }
 
          promoted_stmts = CONS(statement,s,promoted_stmts);
        }
      } else if(promoted_stmts) {
        promoted_stmts = gen_nreverse(promoted_stmts);
        statement promoted = promote_statement(promoted_stmts, l);
        new_stmts = CONS(statement,promoted,CONS(statement,s,new_stmts));
        promoted_stmts = NIL;
 
        ifdebug(2) {
          pips_debug(2,"Promote statements in loop :");
          print_statement(promoted);
        }
      }
    }
    if(promoted_stmts) {
      promoted_stmts = gen_nreverse(promoted_stmts);
      statement promoted = promote_statement(promoted_stmts, l);
      new_stmts = CONS(statement,promoted,new_stmts);
    }
    sequence_statements(seq) = gen_nreverse(new_stmts); // FIXME Free old sequence
  }
}

References CONS, empty_statement_or_continue_p(), FOREACH, gen_nreverse(), ifdebug, NIL, parallel_loop_statement_p(), pips_debug, print_statement(), promote_statement(), and sequence_statements.

Referenced by gpu_promote_sequential_walker_in().

Here is the call graph for this function:

Here is the caller graph for this function:

gpu_promote_sequential_on_statement()

void gpu_promote_sequential_on_statement

(

statement

s

)

Definition at line 139 of file gpu_promote_sequential.c.

                                                      {
  gen_recurse(s,loop_domain,gpu_promote_sequential_walker_in,gen_null);
}

References gen_null(), gen_recurse, gpu_promote_sequential_walker_in(), and loop_domain.

Referenced by gpu_promote_sequential().

Here is the call graph for this function:

Here is the caller graph for this function:

group_constants()

bool group_constants

(

const

string

)

Dependences for accel-util.h.

cproto-generated files group_constants.c

prelude

f entities

gather statement constants

gather constants

pack all constants and perform replacement

validate

ostlude

Parameters

string

odule_name

Definition at line 347 of file group_constants.c.

{
    /* prelude */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_rw_effects((statement_effects) db_get_memory_resource(DBR_REGIONS,module_name,true) );
 
    set/*of entities*/ constants=set_make(set_pointer);;
 
    /* gather statement constants */
    statement constant_statement = find_statement_from_label_name(get_current_module_statement(),module_name,get_string_property("GROUP_CONSTANTS_STATEMENT_LABEL"));
    if(statement_undefined_p(constant_statement))  constant_statement=get_current_module_statement();
    do_group_statement_constant(constant_statement,constants);
 
    /* gather constants */
    gen_context_multi_recurse(constant_statement,constants,
            range_domain,group_constant_range_filter,gen_null,
            call_domain, declaration_filter, gen_null,
            reference_domain,gen_false,gen_null,
            expression_domain,gen_true,do_group_constant_entity,NULL);
 
    /* pack all constants and perform replacement */
    do_group_constants(constant_statement,constants);
 
    set_free(constants);
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
    reset_rw_effects();
    return true;
}

References call_domain, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, declaration_filter(), do_group_constant_entity(), do_group_constants(), do_group_statement_constant(), expression_domain, find_statement_from_label_name(), gen_context_multi_recurse(), gen_false(), gen_null(), gen_true(), get_current_module_statement(), get_string_property(), group_constant_range_filter(), module_name(), module_name_to_entity(), module_reorder(), range_domain, reference_domain, reset_current_module_entity(), reset_current_module_statement(), reset_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_free(), set_make(), set_pointer, set_rw_effects(), and statement_undefined_p.

Here is the call graph for this function:

has_entity_with_same_name()

bool has_entity_with_same_name	(	entity	e,
		list	l
	)

inlining.c

Definition at line 256 of file inlining.c.

                                                 {
    FOREACH(ENTITY,ent,l)
        if(same_entity_name_p(e,ent)) return true;
    return false;
}

References ENTITY, FOREACH, and same_entity_name_p().

Referenced by check_private_variables_loop_walker(), inline_expression_call(), and outliner_independent_recursively().

Here is the call graph for this function:

Here is the caller graph for this function:

ikernel_load_store()

bool ikernel_load_store

(

char *

)

inlining()

bool inlining

(

const char *

module_name

)

perform inlining using effects

Parameters

module_name

name of the module to inline

Returns

Parameters

module_name

odule_name

Definition at line 957 of file inlining.c.

{
  iparam p =IPARAM_INIT;
  use_effects(&p)=true;
        return do_inlining(&p,module_name);
}

References do_inlining(), IPARAM_INIT, module_name(), and use_effects.

Here is the call graph for this function:

inlining_simple()

bool inlining_simple

(

const char *

module_name

)

perform inlining without using effects

Parameters

module_name

name of the module to inline

Returns

Parameters

module_name

odule_name

Definition at line 971 of file inlining.c.

{
  iparam p =IPARAM_INIT;
  use_effects(&p)=false;
        return do_inlining(&p,module_name);
}

References do_inlining(), IPARAM_INIT, module_name(), and use_effects.

Here is the call graph for this function:

is_a_kernel()

bool is_a_kernel

(

const char *

func_name

)

Parameters

func_name

unc_name

Definition at line 369 of file ikernels.c.

                                        {
  callees kernels = (callees)db_get_memory_resource(DBR_KERNELS, "", true);
  bool found = false;
  FOREACH(STRING,kernel_name,callees_callees(kernels)) {
    if((found = (same_string_p(kernel_name,func_name))))
      break;
  }
  return found;
}

References callees_callees, db_get_memory_resource(), FOREACH, same_string_p, and STRING.

Referenced by copy_from_call(), copy_to_call(), kernel_data_mapping(), and opencl_compile_mergeable_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

is_entity_in_list()

bool is_entity_in_list	(	entity	e,
		list	l
	)

Checks if an entity is in a list.

Done by comparing the minimal user name.

Definition at line 688 of file outlining.c.

                                          {
  if (ENDP(l))
    return false;
  FOREACH(entity, ent, l) {
    if (!strcmp(entity_minimal_user_name(ent), entity_minimal_user_name(e)))
      return true;
  }
  return false;
}

References ENDP, entity_minimal_user_name(), and FOREACH.

Referenced by outliner_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_patch_entities()

void isolate_patch_entities	(	void *	where,
		entity	old,
		entity	new,
		list	offsets
	)

replace all references on entity old by references on entity new and adds offset offsets to its indices

Parameters

where	here
old	ld
new	ew
offsets	ffsets

Definition at line 1148 of file isolate_statement.c.

{
    isolate_param p = { old,new,offsets };
    gen_context_multi_recurse(where,&p,
            reference_domain,gen_true,isolate_patch_reference,
            statement_domain,gen_true,isolate_patch_statement,
            0);
}

References gen_context_multi_recurse(), gen_true(), isolate_patch_reference(), isolate_patch_statement(), reference_domain, and statement_domain.

Referenced by effects_to_dma(), and isolate_patch_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_statement()

bool isolate_statement

(

const char *

module_name

)

Returns

a statement holding the loop necessary to initialize new from old, knowing the dimension of the isolated entity dimensions and its offsets offsets and the direction of the transfer t

init stuff

get user input

and proceed

validate

Parameters

module_name

odule_name

Definition at line 1349 of file isolate_statement.c.

{
    /* init stuff */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings(get_current_module_entity());
    set_precondition_map( (statement_mapping) db_get_memory_resource(DBR_PRECONDITIONS, module_name, true) );
 
 
    /* get user input */
    const char* stmt_label=get_string_property("ISOLATE_STATEMENT_LABEL");
    statement statement_to_isolate;
    if(!empty_string_p(stmt_label)) {
      statement_to_isolate = find_statement_from_label_name(get_current_module_statement(),get_current_module_name(),stmt_label);
    } else {
      statement_to_isolate = get_current_module_statement();
    }
    /* and proceed */
    if(statement_undefined_p(statement_to_isolate))
        pips_user_error("statement labeled '%s' not found\n",stmt_label);
    else
    {
        const char* prefix =  get_string_property ("ISOLATE_STATEMENT_VAR_PREFIX");
        const char* suffix =  get_string_property ("ISOLATE_STATEMENT_VAR_SUFFIX");
        pips_debug (5, "isolate_statement prefix : %s\n", prefix);
        pips_debug (5, "isolate_statement suffix : %s\n", suffix);
        do_isolate_statement(statement_to_isolate, prefix, suffix);
    }
 
 
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_precondition_map();
    free_value_mappings();
 
    return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_isolate_statement(), empty_string_p(), find_statement_from_label_name(), free_value_mappings(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), get_string_property(), module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), pips_debug, pips_user_error, prefix, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_precondition_map(), set_proper_rw_effects(), and statement_undefined_p.

Here is the call graph for this function:

kernel_data_mapping()

bool kernel_data_mapping

(

char *

module_name

)

set_entity_to_size(); should be performed at the workspace level

regions

out regions

in regions

preconditions

preconditions

Initialize global hashtables

Initialize set for each statement

Run the pass except if current module is a kernel

Parameters

module_name

odule_name

Definition at line 1344 of file ikernels.c.

                                             {
  statement module_stat;
 
  set_current_module_statement((statement)db_get_memory_resource(DBR_CODE,
                                                                 module_name,
                                                                 true));
  module_stat = get_current_module_statement();
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  /* set_entity_to_size(); should be performed at the workspace level */
 
  debug_on("KERNEL_DATA_MAPPING_DEBUG_LEVEL");
 
 
  /* regions */
  string region = db_get_memory_resource(DBR_REGIONS, module_name, true);
  set_proper_rw_effects((statement_effects)region);
 
 
  /* out regions */
  string or = db_get_memory_resource(DBR_OUT_REGIONS, module_name, true);
  set_out_effects((statement_effects)or);
 
  /* in regions */
  string ir = db_get_memory_resource(DBR_IN_REGIONS, module_name, true);
  set_in_effects((statement_effects)ir);
 
  /* preconditions */
  string precond = db_get_memory_resource(DBR_PRECONDITIONS, module_name, true);
  set_precondition_map((statement_mapping)precond);
 
  /* preconditions */
  string cumu = db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true);
  set_cumulated_rw_effects((statement_effects)cumu);
 
  // Stuff for ... ?
  module_to_value_mappings(get_current_module_entity());
 
 
  /* Initialize global hashtables */
  copies_from_in = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
  copies_from_out = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
  copies_to_in = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
  copies_to_out = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
 
  /* Initialize set for each statement */
  gen_recurse(module_stat, statement_domain, gen_true, init_one_statement);
 
  /* Run the pass except if current module is a kernel */
  if(!is_a_kernel(module_name)) {
    copy_from_statement(module_stat);
    copy_to_statement(module_stat);
    // Is it a bad hack ? Should we need a fix point here ?
    copy_from_statement(module_stat);
 
    transfert_statement(module_stat, MAKE_SET(), MAKE_SET(), MAKE_SET(), MAKE_SET());
  }
 
  ifdebug(1) {
    pips_debug(1,"Interprocedural summary for %s :\n To :",module_name);
    print_entities(set_to_list(COPY_TO_IN(module_stat)));
    fprintf(stderr,"\n From :");
    print_entities(set_to_list(COPY_FROM_OUT(module_stat)));
    fprintf(stderr,"\n");
  }
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,
      module_name,
      module_stat);
 
  DB_PUT_MEMORY_RESOURCE(DBR_KERNEL_COPY_IN,
      module_name,
      make_memory_mapping(COPY_TO_IN(module_stat)));
  DB_PUT_MEMORY_RESOURCE(DBR_KERNEL_COPY_OUT,
      module_name,
      make_memory_mapping(COPY_FROM_OUT(module_stat)));
 
#define TABLE_FREE(t)             \
  {HASH_MAP( k, v, {set_free( (set)v ) ;}, t ) ; hash_table_free(t);}
 
  //  TABLE_FREE(copies_from_in);
  //  TABLE_FREE(copies_from_out);
 
  reset_proper_rw_effects();
  reset_out_effects();
  reset_in_effects();
  reset_precondition_map();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_cumulated_rw_effects();
  free_value_mappings();
 
  return true;
}

References copies_from_in, copies_from_out, copies_to_in, copies_to_out, COPY_FROM_OUT, copy_from_statement(), COPY_TO_IN, copy_to_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_on, fprintf(), free_value_mappings(), gen_recurse, gen_true(), get_current_module_entity(), get_current_module_statement(), hash_pointer, hash_table_make(), ifdebug, init_one_statement(), INIT_STATEMENT_SIZE, is_a_kernel(), local_name_to_top_level_entity(), make_memory_mapping(), MAKE_SET, module_name(), module_to_value_mappings(), pips_debug, print_entities(), region, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), set_to_list(), statement_domain, and transfert_statement().

Here is the call graph for this function:

kernel_load_store()

bool kernel_load_store

(

const char *

module_name

)

kernels.c

kernels.c

based on convex array regions

Parameters

module_name

odule_name

Definition at line 143 of file kernels.c.

                                                {
    return kernel_load_store_engine(module_name, DBR_REGIONS);
}

References kernel_load_store_engine(), and module_name().

Here is the call graph for this function:

kernelize()

bool kernelize

(

const string

module_name

)

turn a loop flagged with LOOP_LABEL into a kernel (GPU, terapix ...)

Parameters

module_name

name of the module

Returns

true

prelude

retreive loop label

run kernelize

validate

ostlude

Parameters

module_name

odule_name

Definition at line 259 of file kernels.c.

{
  /* prelude */
  set_current_module_entity(module_name_to_entity( module_name ));
  set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
 
  /* retreive loop label */
  const char* loop_label_name = get_string_property_or_ask("LOOP_LABEL","label of the loop to turn into a kernel ?\n");
  entity loop_label_entity = find_label_entity(module_name,loop_label_name);
  if( entity_undefined_p(loop_label_entity) )
    pips_user_error("label '%s' not found in module '%s' \n",loop_label_name,module_name);
 
 
  /* run kernelize */
  gen_context_recurse(get_current_module_statement(), loop_label_entity,
                  statement_domain, do_kernelize, gen_null2);
 
  /* validate */
  module_reorder(get_current_module_statement());
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
  /*postlude*/
  reset_current_module_entity();
  reset_current_module_statement();
  return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_kernelize(), entity_undefined_p, find_label_entity(), gen_context_recurse, gen_null2(), get_current_module_statement(), get_string_property_or_ask(), module_name(), module_name_to_entity(), module_reorder(), pips_user_error, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

linearize_array()

bool linearize_array

(

const char *

module_name

)

linearize accesses to an array, and use pointers if asked to

Parameters

module_name

odule_name

Definition at line 987 of file array_to_pointer.c.

{
  return linearize_array_generic (module_name);
}

References linearize_array_generic(), and module_name().

Here is the call graph for this function:

linearize_array_fortran()

bool linearize_array_fortran

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 992 of file array_to_pointer.c.

{
  return linearize_array_generic (module_name);
}

References linearize_array_generic(), and module_name().

Here is the call graph for this function:

linearize_array_generic()

bool linearize_array_generic

(

const char *

module_name

)

linearize accesses to an array, and use pointers if asked to

prelude

Do we have to cast the array at call site ?

it is too dangerous to perform this task on compilation unit, system variables may be changed

just linearize accesses and change signature from n-D arrays to 1-D arrays

additionally perform array-to-pointer conversion for c modules only

validate

ostlude

Parameters

module_name

odule_name

Definition at line 930 of file array_to_pointer.c.

{
 
  debug_on("LINEARIZE_ARRAY_DEBUG_LEVEL");
  /* prelude */
  set_current_module_entity(module_name_to_entity( module_name ));
 
  param_t param = { .use_pointers_p = false , .modify_call_site_p = false, .cast_at_call_site_p = false };
  /* Do we have to cast the array at call site ? */
  if (c_module_p(get_current_module_entity())) {
    param.use_pointers_p      = get_bool_property("LINEARIZE_ARRAY_USE_POINTERS");
    param.cast_at_call_site_p = get_bool_property("LINEARIZE_ARRAY_CAST_AT_CALL_SITE");
  }
  param.modify_call_site_p  = get_bool_property("LINEARIZE_ARRAY_MODIFY_CALL_SITE");
 
  /* it is too dangerous to perform this task on compilation unit, system variables may be changed */
  if(!compilation_unit_entity_p(get_current_module_entity())) {
 
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
 
    /* just linearize accesses and change signature from n-D arrays to 1-D arrays */
    do_linearize_array(get_current_module_entity(),get_current_module_statement(),&param);
 
    /* additionally perform array-to-pointer conversion for c modules only */
    if(param.use_pointers_p) {
      if(c_module_p(get_current_module_entity())) {
        do_array_to_pointer(get_current_module_entity(),get_current_module_statement(),&param);
        cleanup_subscripts(get_current_module_statement());
        FOREACH(ENTITY,e,entity_declarations(get_current_module_entity())) {
          if(entity_variable_p(e)) {
            cleanup_subscripts(entity_initial(e));
          }
        }
      }
      else pips_user_warning("no pointers in fortran !,LINEARIZE_ARRAY_USE_POINTERS ignored\n");
    }
 
    /* validate */
    pips_assert("everything went well",statement_consistent_p(get_current_module_statement()));
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
    if (fortran_module_p(get_current_module_entity()) ) {
      // remove decls_text or the prettyprinter will use that field
      discard_module_declaration_text (get_current_module_entity ());
    } else {
      //compilation unti doesn't exit in fortran
      db_touch_resource(DBR_CODE,compilation_unit_of_module(module_name));
    }
    /*postlude*/
    reset_current_module_statement();
  }
  reset_current_module_entity();
  debug_off();
  return true;
}

References c_module_p(), cleanup_subscripts(), compilation_unit_entity_p(), compilation_unit_of_module(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, db_touch_resource(), debug_off, debug_on, discard_module_declaration_text(), do_array_to_pointer(), do_linearize_array(), ENTITY, entity_declarations, entity_initial, entity_variable_p, false, FOREACH, fortran_module_p(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), pips_assert, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_consistent_p().

Referenced by linearize_array(), and linearize_array_fortran().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_expansion()

bool loop_expansion

(

const char *

module_name

)

loop_expansion.c

first case: statement inserted by loop_expansion_init were illegal

generate guard if no statement to merge or no statement to clean

remove the test statement

second case: statement inserted by loop_expansion_init were legal

remove the test statement and merge

ok for the ui part, let's do something !

commit changes

< we may have add statements

Parameters

module_name

odule_name

Definition at line 261 of file loop_expansion.c.

{
    set_current_module_entity(module_name_to_entity(module_name));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true));
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, get_current_module_name(), true));
 
    debug_on("LOOP_EXPANSION_DEBUG_LEVEL");
    /* first case: statement inserted by loop_expansion_init were illegal */
    list statements_to_clean  = find_statements_with_pragma(get_current_module_statement(),get_string_property("STATEMENT_INSERTION_FAILURE_PRAGMA"));
    list statements_to_merge  = find_statements_with_pragma(get_current_module_statement(),get_string_property("STATEMENT_INSERTION_SUCCESS_PRAGMA"));
    /* generate guard if no statement to merge or no statement to clean */
    bool apply_guard = ENDP(statements_to_merge) && ENDP(statements_to_clean);
 
    /* remove the test statement */
    FOREACH(STATEMENT,statement_to_clean,statements_to_clean)
    {
        update_statement_instruction(statement_to_clean,make_continue_instruction());
        free_extensions(statement_extensions(statement_to_clean));
        statement_extensions(statement_to_clean)=empty_extensions();
    }
 
    /* second case: statement inserted by loop_expansion_init were legal */
    /* remove the test statement and merge */
    FOREACH(STATEMENT,statement_to_clean,statements_to_merge)
    {
        update_statement_instruction(statement_to_clean,make_continue_instruction());
        free_extensions(statement_extensions(statement_to_clean));
        statement_extensions(statement_to_clean)=empty_extensions();
 
    }
 
    gen_free_list(statements_to_clean);
    gen_free_list(statements_to_merge);
 
    const char* lp_label=get_string_property_or_ask(
            "LOOP_LABEL",
            "Which loop do you want to expand?\n(give its label):"
    );
    if( !empty_string_p(lp_label) )
    {
        entity lb_entity = find_label_entity(module_name,lp_label);
        if( !entity_undefined_p(lb_entity) )
        {
            statement loop_statement = find_loop_from_label(get_current_module_statement(),lb_entity);
            if(!statement_undefined_p(loop_statement))
            {
                const char* srate = get_string_property("LOOP_EXPANSION_SIZE");
                expression rate = string_to_expression(srate,get_current_module_entity());
                /* ok for the ui part, let's do something !*/
                do_loop_expansion(loop_statement,rate,get_bool_property("LOOP_EXPANSION_CENTER"),apply_guard);
                /* commit changes */
                module_reorder(get_current_module_statement()); ///< we may have add statements
                DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
            }
            else pips_user_error("label '%s' is not put on a loop\n",lp_label);
 
 
        }
        else pips_user_error("loop label `%s' does not exist\n", lp_label);
    }
    else pips_user_error("transformation cancelled \n", lp_label);
 
    debug_off();
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    return true;;
 
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_loop_expansion(), empty_extensions(), empty_string_p(), ENDP, entity_undefined_p, find_label_entity(), find_loop_from_label(), find_statements_with_pragma(), FOREACH, free_extensions(), gen_free_list(), get_bool_property(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), get_string_property(), get_string_property_or_ask(), make_continue_instruction(), module_name(), module_name_to_entity(), module_reorder(), pips_user_error, 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, statement_extensions, statement_undefined_p, string_to_expression(), and update_statement_instruction().

Here is the call graph for this function:

loop_expansion_init()

bool loop_expansion_init

(

const char *

module_name

)

first step of the loop expansion process: create a statement to insert and flag it with a pragma

ok for the ui part, let's do something !

commit changes

< we may have add statements

Parameters

module_name

odule_name

Definition at line 401 of file loop_expansion.c.

{
    set_current_module_entity(module_name_to_entity(module_name));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true));
 
    debug_on("LOOP_EXPANSION_INIT_DEBUG_LEVEL");
 
 
    const char* lp_label=get_string_property_or_ask(
            "LOOP_LABEL",
            "Which loop do you want to expand?\n(give its label):"
    );
 
    if( !empty_string_p(lp_label) )
    {
        entity lb_entity = find_label_entity(module_name,lp_label);
        if( !entity_undefined_p(lb_entity) )
        {
            statement loop_statement = find_loop_from_label(get_current_module_statement(),lb_entity);
            if(!statement_undefined_p(loop_statement))
            {
                const char* srate = get_string_property("LOOP_EXPANSION_SIZE");
                expression rate =string_to_expression(srate,get_current_module_entity());
                /* ok for the ui part, let's do something !*/
                do_loop_expansion_init(loop_statement,rate);
                /* commit changes */
                module_reorder(get_current_module_statement()); ///< we may have add statements
                DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
            }
            else pips_user_error("label '%s' is not put on a loop\n",lp_label);
 
 
        }
        else pips_user_error("loop label `%s' does not exist\n", lp_label);
    }
    else pips_user_error("transformation cancelled \n", lp_label);
 
    debug_off();
    reset_current_module_entity();
    reset_current_module_statement();
    return true;;
 
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_loop_expansion_init(), empty_string_p(), entity_undefined_p, find_label_entity(), find_loop_from_label(), get_current_module_entity(), get_current_module_statement(), get_string_property(), get_string_property_or_ask(), module_name(), module_name_to_entity(), module_reorder(), pips_user_error, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_undefined_p, and string_to_expression().

Here is the call graph for this function:

normalize_microcode()

bool normalize_microcode

(

char *

module_name

)

prelude

checks

make sure

• only do loops remain
• no call to external functions
• no float / double etc

unroll some loops with constant trip count

reorder some loops

detect initial array sizes

now, try to guess the goal of the parameters

• parameters are 32 bits signed integers (TODO)
• read-only arrays might be mask, but can also be images (depend of their size ?)
• written arrays must be images
• integer are loop parameters
• others are not allowed

reserve some register for internal use

it's a pointer

a rom array with only one element, outlining and isolate_statement where too smart :)

pips bonus step: the consistency

rename all declared entities using terasm convention

need a copy otherwise goes in infinite loop

it's a pointer

it's an int

reorder arguments to match terapix conventions

loops in terasm iterate over a given parameter, in the form DO I=1:N I is hidden to the user and N must be a parameter

normalize test

try some simple optimizations

validate

ostlude

Parameters

module_name

odule_name

Definition at line 626 of file terapixify.c.

{
    bool can_terapixify =true;
    /* prelude */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS,module_name,true));
 
    /* checks */
 
    /* make sure
     * - only do loops remain
     * - no call to external functions
     * - no float / double etc
     */
    gen_context_multi_recurse(get_current_module_statement(),&can_terapixify,
            whileloop_domain,cannot_terapixify,gen_null,
            forloop_domain,cannot_terapixify,gen_null,
            call_domain,can_terapixify_call_p,gen_null,
            expression_domain,can_terapixify_expression_p,gen_null,
            NULL);
 
    /* unroll some loops with constant trip count */
    gen_recurse(get_current_module_statement(),statement_domain, gen_true, terapixify_loops);
    clean_up_sequences(get_current_module_statement());
 
    /* reorder some loops */
    gen_recurse(get_current_module_statement(),statement_domain,gen_true,terapix_loop_optimizer);
 
 
    /* detect initial array sizes */
    normalize_microcode_anotate();
 
    /* now, try to guess the goal of the parameters
     * - parameters are 32 bits signed integers (TODO)
     * - read-only arrays might be mask, but can also be images (depend of their size ?)
     * - written arrays must be images
     * - integer are loop parameters
     * - others are not allowed
     */
    size_t nb_fifo = 1;
    size_t nb_lu = 1;
    size_t nb_ptr = 1;
    size_t nb_ma = 1;
    size_t nb_re = 5;/* reserve some register for internal use */
    FOREACH(ENTITY,e,entity_declarations(get_current_module_entity()))
    {
        if(!entity_area_p(e))
        {
            variable v = type_variable(entity_type(e));
            basic vb = variable_basic(v);
            if(formal_parameter_p(e))
            {
                if( basic_pointer_p(vb) ) /* it's a pointer */
                {
                    string prefix = NULL;
                    type t =ultimate_type(basic_pointer(vb));
                    vb=variable_basic(type_variable(t));
                    if( strstr(entity_user_name(e),get_string_property("GROUP_CONSTANTS_HOLDER")) ) {
                        printf("%s seems a mask\n",entity_user_name(e));
                        prefix = TERAPIX_MASK_PREFIX;
                    }
                    else {
                        printf("%s seems an image\n",entity_user_name(e));
                        prefix = TERAPIX_IMAGE_PREFIX;
                    }
                    terapix_argument_handler(e,TERAPIX_PTRARG_PREFIX,&nb_fifo,prefix,&nb_ptr);
                }
                else if( entity_used_in_loop_bound_p(e) )
                {
                    printf("%s belongs to a loop bound\n",entity_user_name(e));
                    //terapix_argument_handler(e,TERAPIX_LOOPARG_PREFIX,&nb_lu,NULL,NULL);
                }
                /* a rom array with only one element, outlining and isolate_statement where too smart :) */
                else if ( strstr(entity_user_name(e),get_string_property("GROUP_CONSTANTS_HOLDER")) &&
                        entity_scalar_p(e)) {
 
                    entity_type(e) = make_type_variable(
                            make_variable(
                                make_basic_pointer(entity_type(e)),
                                NIL,
                                NIL
                                )
                            );
                    expression repl = MakeUnaryCall(
                            entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
                            entity_to_expression(e)
                            );
                    replace_entity_by_expression(
                            get_current_module_statement(),
                            e,
                            repl);
                    free_expression(repl);
                    /* pips bonus step: the consistency */
                    intptr_t i=1,
                             offset = formal_offset(storage_formal(entity_storage(e)));
                    FOREACH(PARAMETER,p,module_functional_parameters(get_current_module_entity())) {
                        if(i++==offset) {
                            dummy d = parameter_dummy(p);
                            if(dummy_identifier_p(d))
                            {
                                entity di = dummy_identifier(d);
                                entity_type(di) = make_type_variable(
                                        make_variable(
                                            make_basic_pointer(entity_type(di)),
                                            NIL,
                                            NIL
                                            )
                                        );
                            }
                            parameter_type(p) = make_type_variable(
                                    make_variable(
                                        make_basic_pointer(parameter_type(p)),
                                        NIL,
                                        NIL
                                        )
                                    );
                            break;
                        }
                    }
                    list callers = callees_callees((callees)db_get_memory_resource(DBR_CALLERS,get_current_module_name(), true));
                    list callers_statement = callers_to_statements(callers);
                    list call_sites = callers_to_call_sites(callers_statement,get_current_module_entity());
                    pips_assert("only one caller here\n",
                            !ENDP(call_sites) && ENDP(CDR(call_sites)));
                    list args = call_arguments(CALL(CAR(call_sites)));
                    for(intptr_t i=1;i<offset;i++) POP(args);
                    expression *exp = (expression*)REFCAR(args);
                    *exp=
                        MakeUnaryCall(
                                entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),
                                *exp
                                );
 
 
                    for(list citer=callers,siter=callers_statement;!ENDP(citer);POP(citer),POP(siter))
                        DB_PUT_MEMORY_RESOURCE(DBR_CODE, STRING(CAR(citer)),STATEMENT(CAR(siter)));
                    db_touch_resource(DBR_CODE,compilation_unit_of_module(get_current_module_name()));
                    gen_free_list(callers_statement);
 
                    printf("%s seems a mask\n",entity_user_name(e));
                    terapix_argument_handler(e,TERAPIX_PTRARG_PREFIX,&nb_fifo,TERAPIX_MASK_PREFIX,&nb_ma);
                }
            }
            else if( basic_pointer_p(vb) ) {
                terapix_argument_handler(e,NULL,NULL,TERAPIX_IMAGE_PREFIX,&nb_ptr);
            } else if( entity_scalar_p(e))
                terapix_argument_handler(e,NULL,NULL,TERAPIX_REGISTER_PREFIX,&nb_re);
            else
                terapix_argument_handler(e,TERAPIX_PTRARG_PREFIX,&nb_fifo,TERAPIX_MASK_PREFIX,&nb_ma);
        }
    }
 
    /* rename all declared entities using terasm convention*/
    list tmp = gen_copy_seq(statement_declarations(get_current_module_statement()));
    bool stop=true;
    do {
        stop=true;
        /* need a copy otherwise goes in infinite loop */
        FOREACH(ENTITY,e,tmp)
        {
            if(entity_variable_p(e))
            {
                variable v = type_variable(entity_type(e));
                if( basic_pointer_p(variable_basic(v)) ) {/* it's a pointer */
                    if(terapix_pointer_initialized_from_a_mask_p(e)) {
                        force_terapix_argument_handler(e,NULL,NULL,TERAPIX_MASK_PREFIX,&nb_ma);
                        stop=false;
                    }
                    else
                        terapix_argument_handler(e,NULL,NULL,TERAPIX_IMAGE_PREFIX,&nb_ptr);
                }
                else if( basic_int_p(variable_basic(v))) /* it's an int */
                    terapix_argument_handler(e,NULL,NULL,TERAPIX_REGISTER_PREFIX,&nb_re);
            }
        }
    } while(!stop);
    gen_free_list(tmp);
 
    /* reorder arguments to match terapix conventions */
    normalize_microcode_parameter_orders(get_current_module_entity());
 
    /* loops in terasm iterate over a given parameter, in the form DO I=1:N 
     * I is hidden to the user and N must be a parameter */
    {
        terapix_loop_handler_param p = {
            .ht = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE),
            .cnt=&nb_lu
        };
        gen_context_recurse(get_current_module_statement(), &p, statement_domain, gen_true2, terapix_loop_handler);
    }
 
    gen_recurse(get_current_module_statement(), statement_domain,gen_true, stmt_rm_useless_label_rwt);
 
    /* normalize test */
    gen_recurse(get_current_module_statement(), call_domain, gen_true, terapix_normalize_tests);
 
    /* try some simple optimizations */
    clean_up_sequences(get_current_module_statement());
    gen_recurse(get_current_module_statement(),statement_domain,gen_true,terapix_optimize_accumulator);
 
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    return true || can_terapixify;
}

References ADDRESS_OF_OPERATOR_NAME, basic_int_p, basic_pointer, basic_pointer_p, CALL, call_arguments, call_domain, callees_callees, callers_to_call_sites(), callers_to_statements(), can_terapixify_call_p(), can_terapixify_expression_p(), cannot_terapixify(), CAR, CDR, clean_up_sequences(), compilation_unit_of_module(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, db_touch_resource(), DEREFERENCING_OPERATOR_NAME, dummy_identifier, dummy_identifier_p, ENDP, ENTITY, entity_area_p(), entity_declarations, entity_intrinsic(), entity_scalar_p(), entity_storage, entity_to_expression(), entity_type, entity_used_in_loop_bound_p(), entity_user_name(), entity_variable_p, exp, expression_domain, force_terapix_argument_handler(), FOREACH, forloop_domain, formal_offset, formal_parameter_p(), free_expression(), gen_context_multi_recurse(), gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_null(), gen_recurse, gen_true(), gen_true2(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), get_string_property(), HASH_DEFAULT_SIZE, hash_pointer, hash_table_make(), terapix_loop_handler_param::ht, intptr_t, make_basic_pointer(), make_type_variable(), make_variable(), MakeUnaryCall(), module_functional_parameters, module_name(), module_name_to_entity(), module_reorder(), NIL, normalize_microcode_anotate(), normalize_microcode_parameter_orders(), offset, PARAMETER, parameter_dummy, parameter_type, pips_assert, POP, prefix, printf(), REFCAR, replace_entity_by_expression(), 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, statement_declarations, statement_domain, stmt_rm_useless_label_rwt(), storage_formal, STRING, terapix_argument_handler(), TERAPIX_IMAGE_PREFIX, terapix_loop_handler(), terapix_loop_optimizer(), TERAPIX_MASK_PREFIX, terapix_normalize_tests(), terapix_optimize_accumulator(), terapix_pointer_initialized_from_a_mask_p(), TERAPIX_PTRARG_PREFIX, TERAPIX_REGISTER_PREFIX, terapixify_loops(), type_variable, ultimate_type(), variable_basic, and whileloop_domain.

normalize_microcode_anotate()

void normalize_microcode_anotate

(

void

)

terapixify.c

there should be only one caller

Eeny, meeny, miny, moe

get ready for annotation insertion

Definition at line 410 of file terapixify.c.

                                   {
    list callers = callees_callees((callees)db_get_memory_resource(DBR_CALLERS,get_current_module_name(), true));
    /* there should be only one caller */
    string caller = STRING(CAR(callers));
    /* Eeny, meeny, miny, moe */
    FOREACH(entity,fa, module_formal_parameters(get_current_module_entity())) {
        if(entity_pointer_p(fa)) {
            const char* fa_name = entity_user_name(fa);
            entity caller_faname = FindEntityFromUserName(caller,fa_name);
            if(entity_undefined_p(caller_faname)){
                string tmp=strdup(fa_name);
                tmp[strlen(tmp)-1]=0;
                caller_faname = FindEntityFromUserName(caller,tmp);
                free(tmp);
            }
            pips_assert("parameter found",!entity_undefined_p(caller_faname));
            /* get ready for annotation insertion */
            string pragma;
            asprintf(&pragma,"terapix %s",  fa_name);
            FOREACH(DIMENSION, d, variable_dimensions(type_variable(entity_type(caller_faname)))) {
                string tmp = pragma;
                asprintf(&pragma,"%s %d",pragma, dimension_size(d));
                free(tmp);
            }
            add_pragma_str_to_statement(
                    STATEMENT(CAR(statement_block(get_current_module_statement()))),
                    pragma,false);
        }
    }
}

References add_pragma_str_to_statement(), asprintf, callees_callees, CAR, db_get_memory_resource(), DIMENSION, dimension_size(), entity_pointer_p(), entity_type, entity_undefined_p, entity_user_name(), FindEntityFromUserName(), FOREACH, free(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), module_formal_parameters(), pips_assert, STATEMENT, statement_block(), strdup(), STRING, type_variable, and variable_dimensions.

Referenced by normalize_microcode().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_loop_parallel_threshold_set()

bool omp_loop_parallel_threshold_set

(

const char *

module_name

)

Should never arise

Put the new CODE ressource into PIPS:

Parameters

module_name

odule_name

Definition at line 351 of file manage_pragma.c.

                                                              {
  debug_on("OPMIFY_CODE_DEBUG_LEVEL");
  statement mod_stmt = statement_undefined;
  // Get the code and tell PIPS_DBM we do want to modify it
  mod_stmt = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  // Set the current module entity and the current module statement that are
  // required to have many things working in PIPS
  set_current_module_statement(mod_stmt);
  set_current_module_entity(module_name_to_entity(module_name));
 
  // generate pragma string or expression using the correct language:
  value mv = entity_initial(module_name_to_entity(module_name));
  if(value_code_p(mv)) {
    code c = value_code(mv);
    set_prettyprint_language_from_property(language_tag(code_language(c)));
  } else {
    /* Should never arise */
    set_prettyprint_language_from_property(is_language_fortran);
  }
 
  // Add the parallel threshold to all the omp for pragmas
  gen_recurse(mod_stmt, pragma_domain, gen_true, add_loop_parallel_threshold);
 
  /* Put the new CODE ressource into PIPS: */
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, mod_stmt);
  // There is no longer a current module:
  reset_current_module_statement();
  reset_current_module_entity();
 
  pips_debug(2, "done for %s\n", module_name);
  debug_off();
 
  return true;
}

References add_loop_parallel_threshold(), code_language, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, entity_initial, gen_recurse, gen_true(), is_language_fortran, language_tag, module_name(), module_name_to_entity(), pips_debug, pragma_domain, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), set_prettyprint_language_from_property(), statement_undefined, value_code, and value_code_p.

Here is the call graph for this function:

omp_merge_pragma()

bool omp_merge_pragma

(

const char *

module_name

)

merge the pragma on the outer loop

Should never arise

Parameters

module_name

odule_name

Definition at line 297 of file manage_pragma.c.

                                               {
  // Use this module name and this environment variable to set
  statement mod_stmt = PIPS_PHASE_PRELUDE(module_name,
      "OPMIFY_CODE_DEBUG_LEVEL");
 
  /* // generate pragma string or expression using the correct language: */
  value mv = entity_initial(module_name_to_entity(module_name));
  if(value_code_p(mv)) {
    code c = value_code(mv);
    set_prettyprint_language_from_property(language_tag(code_language(c)));
  } else {
    /* Should never arise */
    set_prettyprint_language_from_property(is_language_fortran);
  }
 
  // getting the properties to configure the phase
  const char* merge_policy = get_string_property("OMP_MERGE_POLICY");
  bool outer = (strcmp(merge_policy, "outer") == 0);
 
  // The list of outer loop as a list of statements
  list l_outer = NIL;
 
  // build the list of outer loop with pragma this is also needed by the
  // inner mode
  gen_context_recurse(mod_stmt, &l_outer,
                      loop_domain, build_outer, gen_null2);
 
  if(outer == true) {
    pips_debug(3, "outer mode\n");
    // merge the pragma on the outer loop
    merge_on_outer(l_outer);
  } else { //inner
    pips_debug(3, "inner mode\n");
    // The inner flag
    bool inner_flag = true;
    FOREACH(statement, stmt, l_outer)
    {
      gen_context_recurse(stmt,
                          &inner_flag,
                          loop_domain,
                          inner_filter,
                          inner_rewrite);
    }
  }
 
  // freeing memory
  gen_free_list(l_outer);
 
  //Put back the new statement module
  PIPS_PHASE_POSTLUDE(mod_stmt);
 
  return true;
}

References build_outer(), code_language, entity_initial, FOREACH, gen_context_recurse, gen_free_list(), gen_null2(), get_string_property(), inner_filter(), inner_rewrite(), is_language_fortran, language_tag, loop_domain, merge_on_outer(), module_name(), module_name_to_entity(), NIL, pips_debug, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, set_prettyprint_language_from_property(), value_code, and value_code_p.

Here is the call graph for this function:

ompify_code()

bool ompify_code

(

const char *

)

generate_pragma.c

outline()

bool outline

(

const string

module_name

)

entry point for outline module outlining will be performed using either comment recognition or interactively

Parameters

module_name

name of the module containing the statements to outline

prelude

retrieve name of the outlined module

retrieve statement to outline

apply outlining

validate

ostlude

Parameters

module_name

odule_name

Definition at line 1385 of file outlining.c.

{
    /* prelude */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
    set_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
 
    debug_on("OUTLINE_DEBUG_LEVEL");
 
    /* retrieve name of the outlined module */
    const char* outline_module_name = get_string_property_or_ask("OUTLINE_MODULE_NAME","outline module name ?\n");
 
    // Check the language. In case of Fortran the module name must be in
    // capital letters.
    char * omn=strdup(outline_module_name);
    if(fortran_module_p(get_current_module_entity()))
        omn=strupper(omn,omn);
 
    /* retrieve statement to outline */
    list statements_to_outline = find_statements_with_pragma(get_current_module_statement(),get_string_property("OUTLINE_PRAGMA")) ;
    if(ENDP(statements_to_outline)) {
        const char* label_name = get_string_property("OUTLINE_LABEL");
        if( empty_string_p(label_name) ) {
            statements_to_outline=find_statements_interactively(get_current_module_statement());
        }
        else  {
            statement statement_to_outline = find_statement_from_label_name(get_current_module_statement(),get_current_module_name(),label_name);
            if(statement_undefined_p(statement_to_outline))
                pips_user_error("Could not find loop labeled %s\n",label_name);
            if(statement_loop_p(statement_to_outline) && get_bool_property("OUTLINE_LOOP_STATEMENT"))
                statement_to_outline=loop_body(statement_loop(statement_to_outline));
            statements_to_outline=make_statement_list(statement_to_outline);
        }
    }
 
    /* apply outlining */
    (void)outliner(omn,statements_to_outline);
    free(omn);
 
 
    debug_off();
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,
                           get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
    /*postlude*/
    reset_cumulated_rw_effects();
    reset_rw_effects();
    reset_current_module_entity();
    reset_current_module_statement();
 
    return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, empty_string_p(), ENDP, find_statement_from_label_name(), find_statements_interactively(), find_statements_with_pragma(), fortran_module_p(), free(), get_bool_property(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), get_string_property(), get_string_property_or_ask(), loop_body, make_statement_list, module_name(), module_name_to_entity(), module_reorder(), outliner(), pips_user_error, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_rw_effects(), statement_loop(), statement_loop_p(), statement_to_outline, statement_undefined_p, strdup(), and strupper().

Here is the call graph for this function:

outline_stmts_between_pragmas_in_sequence()

bool outline_stmts_between_pragmas_in_sequence	(	sequence	s,
		void *	_ctx
	)

Parameters

_ctx

ctx

Definition at line 454 of file manage_pragma.c.

                                                                       {
  // Cast of the void pointer
  context *ctx = (context *) _ctx;
  // Are we in a SCoP of the code ?
  bool in_scop = false;
  // A list of the statements contained in the sequence
  list stmts = sequence_statements(s);
  list stmts_to_outline = NIL;
 
  FOREACH(statement, stmt, stmts) {
    // Flag that check if we are at the end of a list of stmts to outline
    bool has_to_outline_p = false;
    // If we are not already in a SCoP of the code and if the statement is preceded
    // by pragma_start
    // Else if we are already in a SCoP of the code and if the statement is followed
    //by pragma_end 
    if(!in_scop && statement_has_this_pragma_string_p(stmt,ctx->pragma_begin)) {
      in_scop = true;
      clear_pragma_on_statement(stmt);
    } else if(in_scop
        && statement_has_this_pragma_string_p(stmt,ctx->pragma_end)) {
      in_scop = false;
      has_to_outline_p = true;
      clear_pragma_on_statement(stmt);
    }
    // If we are in a SCoP : create an one-element statement list (cons) containing stmt 
    if(in_scop) {
      stmts_to_outline = CONS(STATEMENT, stmt, stmts_to_outline );
    }
    // ENDP : true if list is empty, false if is a cons
    if(has_to_outline_p && !ENDP(stmts_to_outline)) {
      // Reverse the order of the list
      stmts_to_outline = gen_nreverse(stmts_to_outline);
      string func_name = build_new_top_level_module_name(ctx->prefix, false);
      // Here we call the outliner on the collected statements
      outliner(func_name, stmts_to_outline);
      // Free the list of statement so that we can continue to build one
      gen_free_list(stmts_to_outline);
      stmts_to_outline = NIL;
 
      // Mark that a substitution have been done
      ctx->outline_done = true;
    }
  }
  if(in_scop) {
    pips_user_warning("End of a sequence with a sentinel starting SCoP pragma "
    "(%s) but did not encountered any pragma end (%s)\n",
                      ctx->pragma_begin, ctx->pragma_end);
  }
  return true;
}

References build_new_top_level_module_name(), clear_pragma_on_statement(), CONS, ENDP, FOREACH, gen_free_list(), gen_nreverse(), NIL, context::outline_done, outliner(), pips_user_warning, context::pragma_begin, context::pragma_end, context::prefix, sequence_statements, STATEMENT, and statement_has_this_pragma_string_p.

Referenced by pragma_outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner()

statement outliner	(	const char *	outline_module_name,
		list	statements_to_outline
	)

outline the statements in statements_to_outline into a module named outline_module_name the outlined statements are replaced by a call to the newly generated module statements_to_outline is modified in place to represent that call

Parameters

outline_module_name	name of the new module
statements_to_outline	is a list of consecutive statements to outline into outline_module_name

Returns

pointer to the newly generated statement (already inserted in statements_to_outline)

1 : init

pass loop bounds as parameters if required

2 : scan

3 : parameters

4 : patch parameters

5 : file

6 : call

7: remove obsolete entities, this is needed otherwise the IR keeps some obsolete data

Parameters

outline_module_name	utline_module_name
statements_to_outline	tatements_to_outline

Definition at line 1327 of file outlining.c.

{
    pips_assert("there are some statements to outline",!ENDP(statements_to_outline));
    entity new_fun = make_empty_subroutine(outline_module_name, copy_language(module_language(get_current_module_entity())));
 
    statement new_body = make_block_statement(statements_to_outline);
 
    /* 1 : init */
    hash_table entity_to_effective_parameter = outliner_init(new_fun, statements_to_outline);
 
    /* pass loop bounds as parameters if required */
    const char* loop_label = get_string_property("OUTLINE_LOOP_BOUND_AS_PARAMETER");
    statement theloop = find_statement_from_label_name(get_current_module_statement(),get_current_module_name(),loop_label);
    if(!statement_undefined_p(theloop) && statement_loop(theloop))
      outliner_extract_loop_bound(theloop,entity_to_effective_parameter);
 
    /* 2 : scan */
    list referenced_entities = outliner_scan(new_fun, statements_to_outline, new_body);
 
    /* 3 : parameters */
    list effective_parameters = NIL;
    list formal_parameters = NIL;
    outliner_parameters(new_fun, new_body, referenced_entities, entity_to_effective_parameter, &effective_parameters, &formal_parameters);
 
    /* 4 : patch parameters */
    if(c_module_p(get_current_module_entity())
       && get_bool_property("OUTLINE_WRITTEN_SCALAR_BY_REFERENCE"))
      outliner_patch_parameters(statements_to_outline, referenced_entities, effective_parameters, formal_parameters, new_body, new_body, new_body);
    
    /* 5 : file */
    outliner_file(new_fun, formal_parameters, &new_body );
 
    /* 6 : call */
    statement new_stmt = outliner_call(new_fun, statements_to_outline, effective_parameters);
    
    /* 7: remove obsolete entities, this is needed otherwise the IR keeps some obsolete data */
    list declared_entities = statements_to_declarations(statements_to_outline);
    FOREACH(ENTITY,de,declared_entities) {
        FOREACH(STATEMENT, sde, statements_to_outline) {
            gen_context_multi_recurse(sde, de, 
                    statement_domain, gen_true, do_remove_entity_from_decl,
                    loop_domain, gen_true, do_remove_entity_from_private,
                    NULL);
            gen_remove(&entity_declarations(get_current_module_entity()), de);
            free_entity(de);
        }
    }
    gen_free_list(declared_entities);
    return new_stmt;
}

References c_module_p(), copy_language(), do_remove_entity_from_decl(), do_remove_entity_from_private(), ENDP, ENTITY, entity_declarations, find_statement_from_label_name(), FOREACH, free_entity(), gen_context_multi_recurse(), gen_free_list(), gen_remove(), gen_true(), get_bool_property(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), get_string_property(), loop_domain, loop_label, make_block_statement(), make_empty_subroutine(), module_language, NIL, outliner_call(), outliner_extract_loop_bound(), outliner_file(), outliner_init(), outliner_parameters(), outliner_patch_parameters(), outliner_scan(), pips_assert, STATEMENT, statement_domain, statement_loop(), statement_undefined_p, and statements_to_declarations().

Referenced by do_kernelize(), gpu_ify_statement(), gpu_memory_apply(), outline(), outline_stmts_between_pragmas_in_sequence(), scalopragma(), and taskify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner_call()

statement outliner_call	(	entity	new_fun,
		list	statements_to_outline,
		list	effective_parameters
	)

and return the replacement statement

perform substitution : replace the original statements by a single call and patch the remaining statement (yes it's ugly)

trash any extensions|comments, they may not be valid now

Parameters

new_fun	ew_fun
statements_to_outline	tatements_to_outline
effective_parameters	ffective_parameters

Definition at line 1235 of file outlining.c.

{
 
    /* and return the replacement statement */
    instruction new_inst =  make_instruction_call(make_call(new_fun,effective_parameters));
    statement new_stmt = statement_undefined;
 
    /* perform substitution :
     * replace the original statements by a single call
     * and patch the remaining statement (yes it's ugly)
     */
    FOREACH(STATEMENT,old_statement,statements_to_outline)
    {
        //free_instruction(statement_instruction(old_statement));
        if(statement_undefined_p(new_stmt))
        {
            statement_instruction(old_statement)=new_inst;
            new_stmt=old_statement;
        }
        else
            statement_instruction(old_statement)=make_continue_instruction();
        gen_free_list(statement_declarations(old_statement));
        statement_declarations(old_statement)=NIL;
        /* trash any extensions|comments, they may not be valid now */
        free_extensions(statement_extensions(old_statement));
        statement_extensions(old_statement)=empty_extensions();
        if(!string_undefined_p(statement_comments(old_statement))) free(statement_comments(old_statement));
        statement_comments(old_statement)=empty_comments;
 
    }
    return new_stmt;
}

References empty_comments, empty_extensions(), FOREACH, free(), free_extensions(), gen_free_list(), make_call(), make_continue_instruction(), make_instruction_call(), NIL, STATEMENT, statement_comments, statement_declarations, statement_extensions, statement_instruction, statement_undefined, statement_undefined_p, and string_undefined_p.

Referenced by compile_mpi(), and outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner_file()

void outliner_file	(	entity	new_fun,
		list	formal_parameters,
		statement *	new_body
	)

prepare parameters and body

5-0 : create new compilation unit

5-1 : add all callees to the same foreign compilation units

5-2: fix the types of the formal parameter in case a new compilation unit is used. Make sure that the function type and the types of the formal parameters are consistent. The function type is correct because the compilation unit has just been parsed.

add a return at the end of the body, in all cases

we can now begin the outlining

et_current_module_entity()

horrible hack to prevent declaration duplication signed : Serge Guelton

we need to free them now, otherwise recompilation fails

Parameters

new_fun	ew_fun
formal_parameters	ormal_parameters
new_body	ew_body

Definition at line 1138 of file outlining.c.

{
    string outline_module_name = (string)entity_user_name(new_fun);
 
    /* prepare parameters and body*/
    module_functional_parameters(new_fun)=formal_parameters;
    FOREACH(PARAMETER,p,formal_parameters) {
      code_declarations(value_code(entity_initial(new_fun))) =
          gen_nconc(code_declarations(value_code(entity_initial(new_fun))),
                    CONS(ENTITY,dummy_identifier(parameter_dummy(p)),NIL));
    }
 
    /* 5-0 : create new compilation unit */
    outliner_compilation_unit(new_fun, formal_parameters);
 
    if(c_module_p(get_current_module_entity()))
        AddEntityToModuleCompilationUnit(new_fun, get_current_module_entity());
 
    /* 5-1 : add all callees to the same foreign compilation units */
    outliner_independent(outline_module_name, *new_body);
 
    /* 5-2: fix the types of the formal parameter in case a new
       compilation unit is used. Make sure that the function type and
       the types of the formal parameters are consistent. The function
       type is correct because the compilation unit has just been
       parsed. */
    if(false) {
      functional ft = type_functional(entity_type(new_fun));
      list fpl = functional_parameters(ft);
      int i, nparams = gen_length(fpl);
 
      for (i = 1; i <= nparams; i++) {
        entity param = find_ith_parameter(new_fun, i);
        type formal_pt = entity_type(param);
        type functional_pt = parameter_type(PARAMETER(CAR(fpl)));
        if(!type_equal_p(formal_pt, functional_pt)) {
          entity_type(param) = copy_type(functional_pt);
        }
        fpl = CDR(fpl);
      }
    }
 
    // In fortran we always want to generate the outline function
    // in its own new file
    char * cun = string_undefined;
    if(fortran_module_p(get_current_module_entity())) {
        ;
    } else if(get_bool_property("OUTLINE_INDEPENDENT_COMPILATION_UNIT")) {
        // Declare in current module so that it's not undefined at call site
        char * the_cu = NULL,*iter;
        if((iter=strchr(outline_module_name,FILE_SEP))) {
            the_cu = strndup(outline_module_name,iter-outline_module_name);
        }
        else the_cu = strdup(outline_module_name);
        asprintf(&cun,"%s" FILE_SEP_STRING, the_cu);
        free(the_cu);
    } 
    else {
        cun = compilation_unit_of_module(get_current_module_name());
    }
    /* add a return at the end of the body, in all cases */
    insert_statement(*new_body, make_return_statement(new_fun), false);
 
    /* we can now begin the outlining */
    bool saved_order = get_bool_property(STAT_ORDER),
         saved_block = get_bool_property("PRETTYPRINT_BLOCKS");
    set_bool_property(STAT_ORDER,false);
    set_bool_property("PRETTYPRINT_BLOCKS",false);
    text t = text_named_module(new_fun, new_fun /*get_current_module_entity()*/, *new_body);
 
 
    add_new_module_from_text(outline_module_name, t, fortran_module_p(get_current_module_entity()),cun);
    if(!string_undefined_p(cun)) free(cun);
    free_text(t);
 
    set_bool_property(STAT_ORDER,saved_order);
    set_bool_property("PRETTYPRINT_BLOCKS",saved_block);
 
 
 
    /* horrible hack to prevent declaration duplication
     * signed : Serge Guelton
     */
    gen_free_list(code_declarations(EntityCode(new_fun)));
    code_declarations(EntityCode(new_fun))=NIL;
 
    /* we need to free them now, otherwise recompilation fails */
    FOREACH(PARAMETER,p,formal_parameters) {
        entity e = dummy_identifier(parameter_dummy(p));
        if(!type_undefined_p(entity_type(e)) &&
                entity_variable_p(e)) {
            free_type(entity_type(e));
            entity_type(e)=type_undefined;
        }
    }
}

References add_new_module_from_text(), AddEntityToModuleCompilationUnit(), asprintf, c_module_p(), CAR, CDR, code_declarations, compilation_unit_of_module(), CONS, copy_type(), dummy_identifier, ENTITY, entity_initial, entity_type, entity_user_name(), entity_variable_p, EntityCode(), FILE_SEP, FILE_SEP_STRING, find_ith_parameter(), FOREACH, fortran_module_p(), free(), free_text(), free_type(), functional_parameters, gen_free_list(), gen_length(), gen_nconc(), get_bool_property(), get_current_module_entity(), get_current_module_name(), insert_statement(), make_return_statement(), module_functional_parameters, NIL, outliner_compilation_unit(), outliner_independent(), PARAMETER, parameter_dummy, parameter_type, set_bool_property(), STAT_ORDER, strdup(), string_undefined, string_undefined_p, strndup(), text_named_module(), type_equal_p(), type_functional, type_undefined, type_undefined_p, and value_code.

Referenced by compile_mpi(), and outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner_init()

hash_table outliner_init	(	entity	new_fun,
		list	statements_to_outline
	)

try to be smart concerning array references

Parameters

new_fun	ew_fun
statements_to_outline	tatements_to_outline

Definition at line 546 of file outlining.c.

{
  /* try to be smart concerning array references */
  if(get_bool_property("OUTLINE_SMART_REFERENCE_COMPUTATION"))
    return outliner_smart_references_computation(statements_to_outline, new_fun);
  else
    return hash_table_make(hash_pointer,1);
}

References get_bool_property(), hash_pointer, hash_table_make(), and outliner_smart_references_computation().

Referenced by compile_mpi(), and outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner_parameters()

void outliner_parameters	(	entity	new_fun,
		statement	new_body,
		list	referenced_entities,
		hash_table	entity_to_effective_parameter,
		list *	effective_parameters_,
		list *	formal_parameters_
	)

all variables are promoted parameters

this create the dummy parameter

FI: when a new compilation unit is used, why declare type in the initial compilation unit? It generates derived types within the wrong compilation unit... and back fires in the prettyprinter

this adds the effective parameter

this is a constant variable or fortran function result

Parameters

new_fun	ew_fun
new_body	ew_body
referenced_entities	eferenced_entities
entity_to_effective_parameter	ntity_to_effective_parameter
effective_parameters_	ffective_parameters_
formal_parameters_	ormal_parameters_

Definition at line 698 of file outlining.c.

{
  string outline_module_name = (string)entity_user_name(new_fun);
 
 
    /* all variables are promoted parameters */
    list effective_parameters = *effective_parameters_;
    list formal_parameters = *formal_parameters_;
    intptr_t i=0;
 
    // Addition for R-Stream compatibility
    // Prevent from adding a parameter if the entity is in the list
    list induction_var = NIL;
    // If no property activated then induction_var should stay to NIL
    bool is_rstream = get_bool_property("OUTLINE_REMOVE_VARIABLE_RSTREAM_IMAGE") || get_bool_property("OUTLINE_REMOVE_VARIABLE_RSTREAM_SCOP");
    if (is_rstream) {
      // Enclosing loops map needed for get_variables_to_remove
      set_enclosing_loops_map(loops_mapping_of_statement(new_body));
      get_variables_to_remove(referenced_entities, new_body, &induction_var);
      clean_enclosing_loops();
      // Adding the declarations to the new body
      add_induction_var_to_local_declarations(&new_body, induction_var);
    }
 
    FOREACH(ENTITY,e,referenced_entities)
      {
        if( (entity_variable_p(e) || entity_symbolic_p(e))  && (!is_entity_in_list(e, induction_var)))
        {
            pips_debug(6,"Add %s to outlined function parameters\n",entity_name(e));
 
            /* this create the dummy parameter */
            entity dummy_entity = FindOrCreateEntity(
                    outline_module_name,
                    entity_user_name(e)
                    );
            entity_initial(dummy_entity)=make_value_unknown();
 
            if(entity_symbolic_p(e))
                entity_type(dummy_entity) = fortran_module_p(new_fun)?
                    copy_type(functional_result(type_functional(entity_type(e)))):
                    make_type_variable(make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),NIL,NIL));
            else {
                if(!fortran_module_p(get_current_module_entity()))
                  /* FI: when a new compilation unit is used, why
                     declare type in the *initial* compilation unit?
                     It generates derived types within the wrong
                     compilation unit... and back fires in the prettyprinter */
                    entity_type(e) = type_to_named_type(entity_type(e),module_entity_to_compilation_unit_entity(get_current_module_entity()));
                entity_type(dummy_entity)=copy_type(entity_type(e));
            }
 
 
            entity_storage(dummy_entity)=make_storage_formal(make_formal(dummy_entity,++i));
 
 
            formal_parameters=CONS(PARAMETER,make_parameter(
                        copy_type(entity_type(dummy_entity)),
                        fortran_module_p(get_current_module_entity())?make_mode_reference():make_mode_value(),
                        make_dummy_identifier(dummy_entity)),formal_parameters);
 
            /* this adds the effective parameter */
            expression effective_parameter = (expression)hash_get(entity_to_effective_parameter,e);
            if(effective_parameter == HASH_UNDEFINED_VALUE)
                effective_parameter = entity_to_expression(e);
 
            effective_parameters=CONS(EXPRESSION,effective_parameter,effective_parameters);
        }
        /* this is a constant variable or fortran function result */
        else if(entity_constant_p(e)||(fortran_module_p(new_fun) && entity_function_p(e))) {
          AddLocalEntityToDeclarations(e,new_fun,new_body);
        }
 
    }
    *formal_parameters_= gen_nreverse(formal_parameters);
    *effective_parameters_= gen_nreverse(effective_parameters);
    hash_table_free(entity_to_effective_parameter);
    gen_free_list(induction_var);
    ifdebug(5) {
      pips_debug(5,"Formals : \n");
      print_parameters(*formal_parameters_);
      pips_debug(5,"Effectives : \n");
      print_expressions(*effective_parameters_);
     }
}

References add_induction_var_to_local_declarations(), AddLocalEntityToDeclarations(), clean_enclosing_loops(), CONS, copy_type(), DEFAULT_INTEGER_TYPE_SIZE, ENTITY, entity_constant_p, entity_function_p(), entity_initial, entity_name, entity_storage, entity_symbolic_p, entity_to_expression(), entity_type, entity_user_name(), entity_variable_p, EXPRESSION, FindOrCreateEntity(), FOREACH, fortran_module_p(), functional_result, gen_free_list(), gen_nreverse(), get_bool_property(), get_current_module_entity(), get_variables_to_remove(), hash_get(), hash_table_free(), HASH_UNDEFINED_VALUE, ifdebug, intptr_t, is_entity_in_list(), loops_mapping_of_statement(), make_basic_int(), make_dummy_identifier(), make_formal(), make_mode_reference(), make_mode_value(), make_parameter(), make_storage_formal(), make_type_variable(), make_value_unknown(), make_variable(), module_entity_to_compilation_unit_entity(), NIL, PARAMETER, pips_debug, print_expressions(), print_parameters(), set_enclosing_loops_map(), type_functional, and type_to_named_type().

Referenced by compile_mpi(), and outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner_patch_parameters()

void outliner_patch_parameters	(	list	statements_to_outline,
		list	referenced_entities,
		list	effective_parameters,
		list	formal_parameters,
		statement	new_body,
		statement	begin,
		statement	end
	)

we need to patch parameters , effective parameters and body in C because parameters are passed by copy in function call it's not needed if

• the parameter is only read (FI: or if it is written before it is read?)
• it's an array / pointer

Here a scalar will be passed by address and a prelude/postlude will be used in the outlined module as below :

void new_module( int *scalar_0 ) { int scalar; scalar = *scalar_0; ... // Work on scalar ... *scalar_0 = scalar; }

Note FI: this is also useless when the variable does not appear in the out region of the outlined piece of code. However, the out effets and out regions are not available for every piece of code.

e is no longer a formal parameter, but a local variable

storage eos = entity_storage(e); // e's old storage

pips_assert("eos is a formal storage", storage_formal_p(eos));

formal fs = storage_formal(eos);

entity f = formal_function(fs); // In fact, f is not a function but a variable!

entity a = module_to_dynamic_area(f);

ram r = make_ram(f, a, UNKNOWN_RAM_OFFSET, NIL);

storage ens = make_storage_ram(r);

entity_storage(e) = ens;

free_storage(eos);

Parameters

statements_to_outline	tatements_to_outline
referenced_entities	eferenced_entities
effective_parameters	ffective_parameters
formal_parameters	ormal_parameters
new_body	ew_body
begin	egin
end	nd

Definition at line 809 of file outlining.c.

{
    list iter  = effective_parameters;
    list riter = referenced_entities;
 
    FOREACH(PARAMETER,p,formal_parameters)
    {
        expression x = EXPRESSION(CAR(iter));
        entity re = ENTITY(CAR(riter));
        entity ex = entity_undefined;
        if(expression_reference_p(x))
            ex = reference_variable(expression_reference(x));
 
        entity e = dummy_identifier(parameter_dummy(p));
        if(!entity_undefined_p(ex)&& type_variable_p(entity_type(ex)) ) {
            variable v = type_variable(entity_type(ex));
            bool entity_written=false;
            FOREACH(STATEMENT,stmt,statements_to_outline) {
                bool write_p = find_write_effect_on_entity(stmt,ex);
                ifdebug(5) {
                    if(write_p) {
                        pips_debug(5,"Entity %s written by statement (%d) : \n",entity_name(ex),the_current_debug_level);
                        print_statement(stmt);
                    }
                }
                entity_written|=write_p;
            }
 
            if( (!basic_pointer_p(variable_basic(v))) &&
                    ENDP(variable_dimensions(v)) &&
                    entity_written
              )
            {
                entity fp = make_entity_copy_with_new_name(e,entity_name(e),false);
                variable_dimensions(type_variable(entity_type(fp)))=
                    gen_append(variable_dimensions(type_variable(entity_type(fp))),
                            CONS(DIMENSION,
                                 make_dimension(int_to_expression(0),
                                                int_to_expression(0),
                                                NIL),
                                 NIL)
                            );
 
                parameter_type(p)=copy_type(entity_type(fp));
                dummy_identifier(parameter_dummy(p))=fp;
 
                //Change at call site (scalar=>&scalar)
                syntax s = expression_syntax(x); // FIXME Leak ?
                expression X = make_expression(s,normalized_undefined);
                expression_syntax(x)=make_syntax_call(make_call(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),CONS(EXPRESSION,X,NIL)));
 
 
                //Create prelude && postlude
                expression dereferenced = MakeUnaryCall(entity_intrinsic(DEREFERENCING_OPERATOR_NAME),entity_to_expression(fp));
 
                // FIXME : is it ok to alias dereferenced expression in 2 statements ?
                statement in = make_assign_statement(entity_to_expression(e),dereferenced);
                statement out = make_assign_statement(dereferenced,entity_to_expression(e));
 
                // Cheat on effects
                store_cumulated_rw_effects_list(in,NIL);
                store_cumulated_rw_effects_list(out,NIL);
 
 
                insert_statement(begin,in,true);
                insert_statement(end,out,false);
 
                /* e is no longer a formal parameter, but a local variable */
                pips_debug(4,"Add declaration for %s",entity_name(e));
 
                /* storage eos = entity_storage(e); // e's old storage */
                /* pips_assert("eos is a formal storage", storage_formal_p(eos)); */
                /* formal fs = storage_formal(eos); */
                /* entity f = formal_function(fs); // In fact, f is *not* a function but a variable! */
                /* // No dependent type assumed, should be a scalar type */
                /* // since a pointer had to be introduced */
                /* entity a = module_to_dynamic_area(f); */
                /* ram r = make_ram(f, a, UNKNOWN_RAM_OFFSET, NIL); */
                /* storage ens = make_storage_ram(r); */
                /* // add_C_variable_to_area() to fix the offset? */
                /* entity_storage(e) = ens; */
                /* free_storage(eos); */
 
                // We could add a push_generated_variable_commenter()
                // to explain the generation
                push_generated_variable_commenter(outlining_patched_variable_commenter);
                add_declaration_statement(new_body,e);
                pop_generated_variable_commenter();
            }
        }
        if(type_variable_p(entity_type(re))) {
            variable v = type_variable(entity_type(re));
            if( basic_pointer_p(variable_basic(v)) &&
                    array_type_p(basic_pointer(variable_basic(v)))) {
                convert_pointer_to_array(e,re,x,statements_to_outline);
 
            }
        }
        POP(iter);
        POP(riter);
    }
    pips_assert("no effective parameter left", ENDP(iter));
}

References add_C_variable_to_area(), add_declaration_statement(), ADDRESS_OF_OPERATOR_NAME, array_type_p(), basic_pointer, basic_pointer_p, CAR, CONS, convert_pointer_to_array(), copy_type(), DEREFERENCING_OPERATOR_NAME, DIMENSION, dummy_identifier, end, ENDP, ENTITY, entity_intrinsic(), entity_name, entity_to_expression(), entity_type, entity_undefined, entity_undefined_p, EXPRESSION, expression_reference(), expression_reference_p(), expression_syntax, find_write_effect_on_entity(), FOREACH, gen_append(), ifdebug, insert_statement(), int_to_expression(), make_assign_statement(), make_call(), make_dimension(), make_entity_copy_with_new_name(), make_expression(), make_syntax_call(), MakeUnaryCall(), NIL, normalized_undefined, offset, out, outlining_patched_variable_commenter(), PARAMETER, parameter_dummy, parameter_type, pips_assert, pips_debug, POP, pop_generated_variable_commenter(), print_statement(), push_generated_variable_commenter(), reference_variable, STATEMENT, store_cumulated_rw_effects_list(), the_current_debug_level, type_variable, type_variable_p, variable_basic, variable_dimensions, X, and x.

Referenced by compile_mpi(), and outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner_scan()

list outliner_scan	(	entity	new_fun,
		list	statements_to_outline,
		statement	new_body
	)

Retrieve referenced entities

Retrieve declared entities

get the relative complements and create the parameter list

purge the functions from the parameter list, we assume they are declared externally also purge the formal parameters from other modules, gathered by get_referenced_entities but wrong here

function should be added to compilation unit

fortran function results must be declared in the new function

remove global variables if needed

sort list, and put parameters first

in some rare case, we can have too functions with the same local name

Parameters

new_fun	ew_fun
statements_to_outline	tatements_to_outline
new_body	ew_body

Definition at line 555 of file outlining.c.

{
    /* Retrieve referenced entities */
    list referenced_entities = outliner_statements_referenced_entities(statements_to_outline);
 
    ifdebug(5) {
      pips_debug(5,"Referenced entities :\n");
      print_entities(referenced_entities);
    }
 
    /* Retrieve declared entities */
    push_generated_variable_commenter(outlining_variable_commenter);
    list localized = statements_localize_declarations(statements_to_outline,new_fun,new_body);
    pop_generated_variable_commenter();
    list declared_entities = statements_to_declarations(statements_to_outline);
    FOREACH(ENTITY,e,declared_entities)
        gen_remove_once(&entity_declarations(get_current_module_entity()),e);
    declared_entities=gen_nconc(declared_entities,localized);
 
    /* get the relative complements and create the parameter list*/
    gen_list_and_not(&referenced_entities,declared_entities);
    gen_free_list(declared_entities);
 
 
    /* purge the functions from the parameter list, we assume they are declared externally
     * also purge the formal parameters from other modules, gathered by get_referenced_entities but wrong here
     */
    list tmp = gen_copy_seq(referenced_entities);
    FOREACH(ENTITY,e,referenced_entities)
    {
        //basic b = entity_basic(e);
        /* function should be added to compilation unit */
        if(entity_function_p(e))
          {
            ;//AddEntityToModuleCompilationUnit(e,get_current_module_entity());
            if(!fortran_module_p(new_fun)) /* fortran function results must be declared in the new function */
            gen_remove_once(&referenced_entities,e);
          }
    }
    gen_free_list(tmp);
 
 
 
    /* remove global variables if needed */
    if(get_bool_property("OUTLINE_ALLOW_GLOBALS"))
    {
        string cu_name = compilation_unit_of_module(get_current_module_name());
        entity cu = module_name_to_entity(cu_name);
        list cu_decls = entity_declarations(cu);
 
        list tmp_list=NIL;
 
        FOREACH(ENTITY,e,referenced_entities)
        {
            if( !top_level_entity_p(e) && gen_chunk_undefined_p(gen_find_eq(e,cu_decls) ) )
                tmp_list=CONS(ENTITY,e,tmp_list);
            else if (gen_chunk_undefined_p(gen_find_eq(e,cu_decls)))
            {
                AddLocalEntityToDeclarations(e,new_fun,new_body);
            }
        }
        gen_free_list(referenced_entities);
        referenced_entities=tmp_list;
    }
 
    /* sort list, and put parameters first */
    sort_entities_with_dep(&referenced_entities);
 
 
    /* in some rare case, we can have too functions with the same local name */
    outline_remove_duplicates(&referenced_entities);
    return referenced_entities;
}

References AddLocalEntityToDeclarations(), compilation_unit_of_module(), CONS, ENTITY, entity_declarations, entity_function_p(), FOREACH, fortran_module_p(), gen_chunk_undefined_p, gen_copy_seq(), gen_find_eq(), gen_free_list(), gen_list_and_not(), gen_nconc(), gen_remove_once(), get_bool_property(), get_current_module_entity(), get_current_module_name(), ifdebug, module_name_to_entity(), NIL, outline_remove_duplicates(), outliner_statements_referenced_entities(), outlining_variable_commenter(), pips_debug, pop_generated_variable_commenter(), print_entities(), push_generated_variable_commenter(), sort_entities_with_dep(), statements_localize_declarations(), statements_to_declarations(), and top_level_entity_p().

Referenced by compile_mpi(), and outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

outliner_statements_referenced_entities()

list outliner_statements_referenced_entities

(

list

statements

)

outlining.c

we don't want initial values of outer entities

gather local initial values skipped by the previous call

set to list

Parameters

statements

tatements

Definition at line 251 of file outlining.c.

{
    list referenced_entities = NIL;
    set sreferenced_entities = set_make(set_pointer);
 
    FOREACH(STATEMENT, s, statements)
    {
        /* we don't want initial values of outer entities */
        set tmp = get_referenced_entities_filtered(s,skip_values,skip_constants_intrinsics_members);
        /* gather local initial values skipped by the previous call*/
        list decl = statement_to_declarations(s);
        FOREACH(ENTITY,e,decl) {
            set se = get_referenced_entities_filtered(entity_initial(e),skip_values,skip_constants_intrinsics_members);
            set_union(tmp,tmp,se);
            set_free(se);
            se = get_referenced_entities_filtered(entity_type(e),skip_values,skip_constants_intrinsics_members);
            set_union(tmp,tmp,se);
            set_free(se);
        }
 
        ifdebug(7) {
          pips_debug(7,"Statement :");
          print_statement(s);
          pips_debug(7,"referenced entities :");
          print_entities(set_to_list(tmp));
          fprintf(stderr,"\n");
        }
 
        set_union(sreferenced_entities,tmp,sreferenced_entities);
        set_free(tmp);
    }
    /* set to list */
    referenced_entities=set_to_list(sreferenced_entities);
    set_free(sreferenced_entities);
    return referenced_entities;
}

References ENTITY, entity_initial, entity_type, FOREACH, fprintf(), get_referenced_entities_filtered(), ifdebug, NIL, pips_debug, print_entities(), print_statement(), set_free(), set_make(), set_pointer, set_to_list(), set_union(), skip_constants_intrinsics_members(), skip_values(), STATEMENT, and statement_to_declarations().

Referenced by outliner_scan(), outliner_smart_references_computation(), and update_referenced_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_omp_p()

bool pragma_omp_p

(

pragma

p

)

Check that a pragma is an "omp" one.

Definition at line 78 of file manage_pragma.c.

                            {
  bool pragma_omp = false;
  if(pragma_expression_p(p)) {
    list expr = pragma_expression(p);
    // The list is reversed !
    expression begin = EXPRESSION(CAR(gen_last(expr)));
    if(expression_call_p(begin)) {
      entity called = call_function(expression_call(begin));
      if(same_string_p(OMP_OMP_FUNCTION_NAME,entity_local_name(called) )) {
        pragma_omp = true;
      }
    }
  } else if(pragma_string_p(p)) {
    if(strncasecmp("omp", pragma_string(p), 3) == 0) {
      pragma_omp = true;
    }
  } else {
    pips_internal_error("We don't know how to handle this kind of pragma !\n");
  }
  return pragma_omp;
}

References call_function, CAR, entity_local_name(), EXPRESSION, expression_call(), expression_call_p(), gen_last(), OMP_OMP_FUNCTION_NAME, pips_internal_error, pragma_expression, pragma_expression_p, pragma_string, pragma_string_p, and same_string_p.

Referenced by build_omp_pragma_list().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_outliner()

bool pragma_outliner

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 512 of file manage_pragma.c.

                                         {
  // Standard procedure for phases
  set_current_module_entity(local_name_to_top_level_entity(module_name));
 
  set_current_module_statement((statement) db_get_memory_resource(DBR_CODE,
                                                                  module_name,
                                                                  true));
  statement module_stat = get_current_module_statement();
 
  // Needed for outliner !
  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));
  // Needed for outliner using option OUTLINE_SMART_REFERENCE_COMPUTATION TRUE
  set_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
  // Needed for induction variable removal
  module_to_value_mappings(get_current_module_entity());
  set_transformer_map((statement_mapping)db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
  set_precondition_map((statement_mapping)db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
  
  set_methods_for_convex_effects();
 
  // Recursion context
  // Getting the parameters of the pragmas in order to be able to parse them later
  context ctx;
  ctx.pragma_begin = (string) get_string_property("PRAGMA_OUTLINER_BEGIN");
  ctx.pragma_end = (string) get_string_property("PRAGMA_OUTLINER_END");
  ctx.prefix = (string) get_string_property("PRAGMA_OUTLINER_PREFIX");
  ctx.outline_done = false;
  // Recurse over sequence
  gen_context_recurse(module_stat, &ctx,
    sequence_domain, outline_stmts_between_pragmas_in_sequence, gen_null2);
  // If a substitution has been done correctly, we put the new resources
  if(ctx.outline_done) {
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES,
                           module_name,
                           compute_callees(module_stat));
 
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  }
  // Standard procedure for reseting after a phase
  reset_rw_effects();
  generic_effects_reset_all_methods();
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_current_module_entity();
  reset_current_module_statement();
  reset_precondition_map();
  reset_transformer_map();
  free_value_mappings();
  return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, free_value_mappings(), gen_context_recurse, gen_null2(), generic_effects_reset_all_methods(), get_current_module_entity(), get_current_module_statement(), get_string_property(), local_name_to_top_level_entity(), module_name(), module_to_value_mappings(), context::outline_done, outline_stmts_between_pragmas_in_sequence(), context::pragma_begin, context::pragma_end, context::prefix, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), reset_transformer_map(), sequence_domain, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_methods_for_convex_effects(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), and set_transformer_map().

Here is the call graph for this function:

region_to_dimensions()

void region_to_dimensions	(	effect	reg,
		transformer	tr,
		list *	dimensions,
		list *	offsets,
		expression *	condition
	)

isolate_statement.c

Parameters

reg	eg
tr	r
dimensions	imensions
offsets	ffsets
condition	ondition

Definition at line 204 of file isolate_statement.c.

                                                                                                               {
    pips_assert("effects are regions\n",effect_region_p(reg));
    if( ! region_to_minimal_dimensions(reg,tr,dimensions,offsets,true,condition) ) {
        pips_user_warning("failed to convert regions to minimal array dimensions, using whole array instead\n");
 
        bool success_p = false;
        // Try using a region based on the declaration (Old way)
        //success_p=declaration_region_to_dimensions(reg,tr,dimensions,offsets,condition);
 
        // Use directly the dimensions from the declaration without building a region!
        entity e = reference_variable(region_any_reference(reg));
        success_p=declarations_to_dimensions(e, dimensions, offsets);
 
        if(!success_p) {
          // Don't know how to recover from that...
          pips_internal_error("Abort");
        }
    }
}

References declarations_to_dimensions(), effect_region_p, pips_assert, pips_internal_error, pips_user_warning, reference_variable, region_any_reference, and region_to_minimal_dimensions().

Referenced by effects_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

region_to_minimal_dimensions()

bool region_to_minimal_dimensions	(	effect	,
		transformer	,
		list *	,
		list *	,
		bool	,
		expression *
	)

remove_from_effective_parameters()

void remove_from_effective_parameters	(	list	induction_var,
		list *	effective_parameters
	)

Parameters

induction_var	nduction_var
effective_parameters	ffective_parameters

Definition at line 1288 of file outlining.c.

                                                                                      {
  list eff_par = gen_copy_seq(*effective_parameters);
  FOREACH(entity, ent, induction_var) {
    FOREACH(expression, exp, eff_par) {
      entity exp_ent = expression_to_entity(exp);
      if (!entity_undefined_p(exp_ent) && !strcmp(entity_minimal_user_name(exp_ent), entity_minimal_user_name(ent))) {
        printf("removing : \n");
        printf("effective parameter \n");
        printf("%s\n", entity_minimal_user_name(exp_ent));
        printf("induction var\n");
        printf("%s\n", entity_minimal_user_name(ent));
        printf("\n\n");
        gen_remove_once(effective_parameters, exp);
      }
    }
  }
  gen_free_list(eff_par);
}

References entity_minimal_user_name(), entity_undefined_p, exp, expression_to_entity(), FOREACH, gen_copy_seq(), gen_free_list(), gen_remove_once(), and printf().

Here is the call graph for this function:

remove_from_formal_parameters()

void remove_from_formal_parameters	(	list	induction_var,
		list *	formal_parameters
	)

Parameters

induction_var	nduction_var
formal_parameters	ormal_parameters

Definition at line 1268 of file outlining.c.

                                                                                {
  list form_par = gen_copy_seq(*formal_parameters);
  FOREACH(entity, ent, induction_var) {
    FOREACH(parameter, param, form_par) {
      dummy dum = parameter_dummy(param);
      entity param_ent = dummy_identifier(dum);
      if (!entity_undefined_p(ent) && !strcmp(entity_minimal_user_name(param_ent), entity_minimal_user_name(ent))) {
        printf("removing : \n");
        printf("formal parameter \n");
        printf("%s\n", entity_minimal_user_name(param_ent));
        printf("induction var\n");
        printf("%s\n", entity_minimal_user_name(ent));
        printf("\n\n");
        gen_remove_once(formal_parameters, param);
      }
    }
  }
  gen_free_list(form_par);
}

References dummy_identifier, entity_minimal_user_name(), entity_undefined_p, FOREACH, gen_copy_seq(), gen_free_list(), gen_remove_once(), parameter_dummy, and printf().

Here is the call graph for this function:

remove_preferences()

void remove_preferences

(

void *

obj

)

delay.c

delay.c

Parameters

obj

bj

Definition at line 89 of file delay.c.

                                    {
    gen_recurse(obj, cell_domain, do_remove_preference, gen_null);
}

References cell_domain, do_remove_preference(), gen_null(), and gen_recurse.

Referenced by delay_communications(), delay_load_communications(), delay_store_communications(), loop_annotate(), and simdizer().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_dma_stat_p()

bool simd_dma_stat_p

(

statement

stat

)

This function returns true if the statement is a simd loadsave statement.

Parameters

stat

tat

Definition at line 127 of file delay.c.

{
    return simd_load_stat_p(stat) || simd_store_stat_p(stat);
}

References simd_load_stat_p(), and simd_store_stat_p().

Referenced by dmas_invert_p(), do_remove_redundant_communications_in_anyloop(), do_remove_redundant_communications_in_sequence(), select_independent_dmas(), simd_stat_p(), and simd_trace_call().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_load_stat_p()

bool simd_load_stat_p

(

statement

stat

)

Parameters

stat

tat

Definition at line 111 of file delay.c.

{
  return statement_call_p(stat) && simd_load_call_p(statement_call(stat));
}

References simd_load_call_p(), statement_call(), and statement_call_p().

Referenced by delay_communications_call(), do_recurse_statements_conflict_p(), and simd_dma_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_stat_p()

bool simd_stat_p

(

statement

stat

)

This function returns true if the statement is a simd statement.

Parameters

stat

tat

Definition at line 135 of file delay.c.

{
    return simd_dma_stat_p(stat) || simd_work_stat_p(stat);
}

References simd_dma_stat_p(), and simd_work_stat_p().

Here is the call graph for this function:

simd_store_stat_p()

bool simd_store_stat_p

(

statement

stat

)

Parameters

stat

tat

Definition at line 119 of file delay.c.

{
  return statement_call_p(stat) && simd_store_call_p(statement_call(stat));
}

References simd_store_call_p(), statement_call(), and statement_call_p().

Referenced by delay_communications_call(), simd_dma_stat_p(), statements_conflict_p(), and statements_conflict_relaxed_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_work_stat_p()

bool simd_work_stat_p

(

statement

stat

)

Parameters

stat

tat

Definition at line 115 of file delay.c.

{
  return statement_call_p(stat) && simd_work_call_p(statement_call(stat));
}

References simd_work_call_p(), statement_call(), and statement_call_p().

Referenced by simd_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

solve_hardware_constraints()

bool solve_hardware_constraints

(

const char *

module_name

)

constraints.c

validate

Parameters

module_name

odule_name

Definition at line 267 of file constraints.c.

{
    debug_on("SOLVE_HARDWARE_CONSTRAINTS");
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings(get_current_module_entity());
    set_precondition_map( (statement_mapping) db_get_memory_resource(DBR_PRECONDITIONS, module_name, true) );
 
    const char* stmt_label=get_string_property("SOLVE_HARDWARE_CONSTRAINTS_LABEL");
    statement equation_to_solve = find_statement_from_label_name(get_current_module_statement(),get_current_module_name(),stmt_label);
 
    bool result =false;
    if(!statement_undefined_p(equation_to_solve))
    {
        if((result=do_solve_hardware_constraints(equation_to_solve))) {
            /* validate */
            module_reorder(get_current_module_statement());
            DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
        }
    }
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_precondition_map();
    free_value_mappings();
    debug_off();
    return result;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_solve_hardware_constraints(), find_statement_from_label_name(), free_value_mappings(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), get_string_property(), module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_precondition_map(), set_proper_rw_effects(), and statement_undefined_p.

Here is the call graph for this function:

statement_has_omp_parallel_directive_p()

bool statement_has_omp_parallel_directive_p

(

statement

s

)

manage_pragma.c

Definition at line 52 of file manage_pragma.c.

                                                         {
  bool found = false;
  FOREACH(EXTENSION, ex, extensions_extension(statement_extensions(s))) {
    pragma p = extension_pragma(ex);
    if(pragma_string_p(p)) {
      string ps = pragma_string(p);
      if((found = (strstr(ps, "omp parallel") || strstr(ps, "OMP PARALLEL"))))
        goto found;
    } else if(pragma_expression_p(p)) {
      FOREACH(EXPRESSION, pe, pragma_expression(p))
      {
        if(expression_call_p(pe)) {
          call c = expression_call(pe);
          if((found = (same_entity_p(call_function(c),
                                     CreateIntrinsic(OMP_OMP_FUNCTION_NAME)))))
            goto found;
        }
      }
    }
  }
  found: return found;
}

References call_function, CreateIntrinsic(), EXPRESSION, expression_call(), expression_call_p(), EXTENSION, extension_pragma, extensions_extension, FOREACH, OMP_OMP_FUNCTION_NAME, pragma_expression, pragma_expression_p, pragma_string, pragma_string_p, same_entity_p(), and statement_extensions.

Here is the call graph for this function:

statement_insertion()

bool statement_insertion

(

const char *

module_name

)

statement_insertion.c

init

do

validate

Parameters

module_name

odule_name

Definition at line 240 of file statement_insertion.c.

{
    /* init */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
    debug_on("STATEMENT_INSERTION_DEBUG_LEVEL");
 
    /* do */
    if(do_statement_insertion(get_current_module_statement()))
    {
        /* validate */
        module_reorder(get_current_module_statement());
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
    }
 
    debug_off();
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_statement_insertion(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and set_proper_rw_effects().

Here is the call graph for this function:

terapix_loop_optimizer()

void terapix_loop_optimizer

(

statement

st

)

look for iterators from the end

now try to hide the iteration in a pointer access somewhere

Parameters

st

t

Definition at line 498 of file terapixify.c.

                                          {
    if(statement_loop_p(st)) {
        loop l =statement_loop(st);
 
        statement sb = loop_body(l);
        entity fake = make_new_scalar_variable(get_current_module_entity(),make_basic_int(DEFAULT_INTEGER_TYPE_SIZE));
        AddLocalEntityToDeclarations(fake,get_current_module_entity(),sb);
        if(statement_block_p(sb)) {
            list block = statement_block(sb);
            list bblock = gen_nreverse(gen_copy_seq(block));
            list added = NIL;
 
            /* look for iterators from the end */
            FOREACH(STATEMENT,s,bblock) {
                if(assignment_statement_p(s)) {
                    call c = statement_call(s);
                    expression lhs = binary_call_lhs(c),
                               rhs = binary_call_rhs(c);
                    if(expression_call_p(rhs)) {
                        call c = expression_call(rhs);
                        entity op = call_function(c);
                        if(ENTITY_PLUS_C_P(op) || ENTITY_MINUS_C_P(op)) {
                            bool plus = ENTITY_PLUS_C_P(op);
                            intptr_t step;
                            if(expression_equal_p(binary_call_lhs(c),lhs) &&
                                    expression_integer_value(binary_call_rhs(c),&step)&&step==1) {
                                entity iterator = expression_to_entity(lhs);
                                statement copy = copy_statement(s);
                                call_function(expression_call(binary_call_rhs(statement_call(copy))))=
                                    entity_intrinsic(plus?MINUS_C_OPERATOR_NAME:PLUS_C_OPERATOR_NAME);
 
                                gen_remove(&block,s);
                                /* now try to hide the iteration in a pointer access somewhere */
                                tlo_context_t ctxt = {iterator,plus,false };
                                FOREACH(STATEMENT,ss,block) {
                                    set re = get_referenced_entities(ss);
                                    if(set_belong_p(re,iterator)) {
                                        gen_context_recurse(ss,&ctxt,call_domain,do_terapix_loop_optimizer,gen_null2);
                                        if(ctxt.success) {
                                            set_free(re);
                                            break;
                                        }
                                    }
                                    set_free(re);
                                }
                                if(!ctxt.success)
                                    block=CONS(STATEMENT,s,block);
                                else
                                    free_statement(s);
                                added=CONS(STATEMENT,copy,added);
                                continue;
                            }
                        }
                    }
                }
                break;
            }
            sequence_statements(statement_sequence(sb))=block;
            gen_free_list(bblock);
            if(!ENDP(added)) {
                added=gen_nreverse(added);
                insert_statement(st,make_block_statement(added),true);
            }
        }
    }
}

References AddLocalEntityToDeclarations(), assignment_statement_p(), binary_call_lhs, binary_call_rhs, call_domain, call_function, CONS, copy_statement(), DEFAULT_INTEGER_TYPE_SIZE, do_terapix_loop_optimizer(), ENDP, entity_intrinsic(), ENTITY_MINUS_C_P, ENTITY_PLUS_C_P, expression_call(), expression_call_p(), expression_equal_p(), expression_integer_value(), expression_to_entity(), FOREACH, free_statement(), gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_nreverse(), gen_null2(), gen_remove(), get_current_module_entity(), get_referenced_entities(), insert_statement(), intptr_t, loop_body, make_basic_int(), make_block_statement(), make_new_scalar_variable(), MINUS_C_OPERATOR_NAME, NIL, PLUS_C_OPERATOR_NAME, sequence_statements, set_belong_p(), set_free(), STATEMENT, statement_block(), statement_block_p, statement_call(), statement_loop(), statement_loop_p(), statement_sequence(), and tlo_context_t::success.

Referenced by normalize_microcode().

Here is the call graph for this function:

Here is the caller graph for this function:

terapix_remove_divide()

bool terapix_remove_divide

(

const

string

)

prelude

converts divide operator into multiply operator: a/cste = a* (1/b) ~= a * ( 128 / cste ) / 128

validate

ostlude

Parameters

string

odule_name

Definition at line 1045 of file terapixify.c.

{
    /* prelude */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
 
    /* converts divide operator into multiply operator:
     * a/cste = a* (1/b) ~= a * ( 128 / cste ) / 128
     */
    gen_recurse(get_current_module_statement(),call_domain,gen_true,do_terapix_remove_divide);
 
    /* validate */
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
    return true;
}

References call_domain, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_terapix_remove_divide(), gen_recurse, gen_true(), get_current_module_statement(), module_name(), module_name_to_entity(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), and set_current_module_statement().

Here is the call graph for this function:

terapix_warmup()

bool terapix_warmup

(

const char *

module_name

)

prelude

go go power rangers

validate

ostlude

Parameters

module_name

odule_name

Definition at line 908 of file terapixify.c.

                                              {
    /* prelude */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
 
    /* go go power rangers */
    bool can_terapixify =
        do_terapix_warmup(get_current_module_statement());
    
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
    return  can_terapixify;
 
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_terapix_warmup(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), and set_current_module_statement().

Here is the call graph for this function:

type_dereferencement_depth()

size_t type_dereferencement_depth

(

type

t

)

Returns

the number of dimensions in

Parameters

t,counting

pointers as a dimension

BEWARE: does not take structs and unions into account

Definition at line 89 of file array_to_pointer.c.

                                          {
  t = ultimate_type(t);
  if(type_variable_p(t)) {
    ifdebug(8) {
      pips_debug(8,"Type is : ");
      print_type(t);
    }
    variable v = type_variable(t);
    basic b = variable_basic(v);
    return gen_length(variable_dimensions(v)) + (basic_pointer_p(b) ? 1
        + type_dereferencement_depth(basic_pointer(b)) : 0);
  }
  return 0;
}

References basic_pointer, basic_pointer_p, gen_length(), ifdebug, pips_debug, print_type(), type_dereferencement_depth(), type_variable, type_variable_p, ultimate_type(), variable_basic, and variable_dimensions.

Referenced by type_dereferencement_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

unfolding()

bool unfolding

(

char *

module_name

)

perform unfolding using effect

Parameters

module_name

name of the module to unfold

Returns

Parameters

module_name

odule_name

Definition at line 1118 of file inlining.c.

{
  iparam p = IPARAM_INIT;
  use_effects(&p)=true;
        return do_unfolding(&p,module_name);
}

References do_unfolding(), IPARAM_INIT, module_name(), and use_effects.

Here is the call graph for this function:

unfolding_simple()

bool unfolding_simple

(

char *

module_name

)

perform unfolding without using effects

Parameters

module_name

name of the module to unfold

Returns

true upon success

Parameters

module_name

odule_name

Definition at line 1133 of file inlining.c.

{
    iparam p = IPARAM_INIT;
    use_effects(&p)=false;
        return do_unfolding(&p,module_name);
}

References do_unfolding(), IPARAM_INIT, module_name(), and use_effects.

Here is the call graph for this function:

variable_to_dimensions()

list variable_to_dimensions

(

effect

)

wrap_kernel_argument()

bool wrap_kernel_argument

(

char *

module_name

)

This pass will wrap kernel arguments in a call to a wrapper function.

prelude

o the job

validate

ostlude

Parameters

module_name

odule_name

Definition at line 1486 of file ikernels.c.

                                              {
 
  entity kernel_entity = local_name_to_top_level_entity(module_name);
 
  debug_on("WRAP_KERNEL_ARGUMENT_DEBUG_LEVEL");
 
  callees callers = (callees)db_get_memory_resource(DBR_CALLERS,
                                                    module_name,
                                                    true);
 
  // Get the wrapper function
  const char* function_name = get_string_property("WRAP_KERNEL_ARGUMENT_FUNCTION_NAME");
  wrapper_function = module_name_to_entity(function_name);
  if(entity_undefined_p(wrapper_function)) {
    wrapper_function
        = make_empty_subroutine(function_name,
                                copy_language(module_language(kernel_entity)));
    pips_user_warning("Cannot find \"%s\" method. Are you sure you have set\n"
        "WRAP_KERNEL_ARGUMENT_FUNCTION_NAME"
        "to a defined entity and added the correct .c file?\n",function_name);
  }
 
 
 
 
  FOREACH(STRING,caller_name,callees_callees(callers)) {
    /* prelude */
    set_current_module_entity(module_name_to_entity(caller_name));
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE,
                                                                   caller_name,
                                                                   true));
 
    /*do the job */
    gen_context_recurse(get_current_module_statement(), module_name,
                    call_domain, gen_true2, wrap_call_argument);
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, caller_name,get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, caller_name, compute_callees(get_current_module_statement()));
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
  }
 
  return true;
}

References call_domain, callees_callees, caller_name, compute_callees(), copy_language(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_on, entity_undefined_p, FOREACH, gen_context_recurse, gen_true2(), get_current_module_statement(), get_string_property(), local_name_to_top_level_entity(), make_empty_subroutine(), module_language, module_name(), module_name_to_entity(), module_reorder(), pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), STRING, wrap_call_argument(), and wrapper_function.

Here is the call graph for this function: