25 #include "pips_config.h"
96 bool thread_safe_p =
true;
103 thread_safe_p =
false;
107 ignore_p = thread_safe_p;
132 fprintf(stderr,
"The list of privatized/private variables : \n");
134 fprintf(stderr,
"\nThe list of locally declared variables : \n");
184 loops1 =
CDR(loops1);
187 loops2 =
CDR(loops2);
191 pips_debug(8,
"verifying the following conflit at level %d: \n",l);
193 "\t%02td --> %02td ",
259 "\t%02td --> %02td ",
313 bool task_parallelize_p) {
330 task_parallelize_inner =
333 : task_parallelize_p;
340 task_parallelize_inner));
356 bool task_parallelize_p) {
363 if(*lst !=
NIL && nbl) {
397 bool task_parallelize_p) {
410 pips_debug(9,
"Begin: starting at level %d ...\n", l);
414 pips_debug(9,
"finding and top-sorting sccs ...\n");
558 pips_assert(
"Execution is either parallel or sequential",
621 bool task_parallelize_inner;
628 seq_or_par = (!task_parallelize_p
634 task_parallelize_inner
637 : task_parallelize_p;
644 task_parallelize_inner);
651 return MakeLoopAs(slo, seq_or_par, inner_stat);
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
execution make_execution(enum execution_utype tag, void *val)
range copy_range(range p)
RANGE.
loop make_loop(entity a1, range a2, statement a3, entity a4, execution a5, list a6)
statement make_statement(entity a1, intptr_t a2, intptr_t a3, string a4, instruction a5, list a6, string a7, extensions a8, synchronization a9)
instruction make_instruction(enum instruction_utype tag, void *val)
synchronization make_synchronization_none(void)
extensions copy_extensions(extensions p)
EXTENSIONS.
#define dg_vertex_label_statement(x)
struct _newgen_struct_dg_arc_label_ * dg_arc_label
#define CONFLICT(x)
CONFLICT.
#define dg_arc_label_conflicts(x)
#define conflict_source(x)
struct _newgen_struct_dg_vertex_label_ * dg_vertex_label
#define region
simulation of the type region
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
#define action_write_p(x)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
#define successor_vertex(x)
#define successor_arc_label(x)
#define vertex_vertex_label(x)
#define vertex_successors(x)
#define SUCCESSOR(x)
SUCCESSOR.
statement make_block_statement(list)
Make a block statement from a list of statement.
bool index_private_p(loop lo)
returns true if loop lo's index is private for this loop
#define ENDP(l)
Test if a list is empty.
#define NIL
The empty list (nil in Lisp)
list gen_copy_seq(list l)
Copy a list structure.
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
void * gen_find_eq(const void *item, const list seq)
#define MAPL(_map_list_cp, _code, _l)
Apply some code on the addresses of all the elements of a list.
#define list_undefined
Undefined list definition :-)
loop statement_loop(statement)
Get the loop of a statement.
bool continue_statement_p(statement)
Test if a statement is a CONTINUE, that is the FORTRAN nop, the ";" in C or the "pass" in Python....
bool declaration_statement_p(statement)
Had to be optimized according to Beatrice Creusillet.
statement vertex_to_statement(vertex v)
Vertex_to_statement looks for the statement that is pointed to by vertex v.
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define STATEMENT_ORDERING_UNDEFINED
mapping.h inclusion
bool set_belong_p(const set, const void *)
set set_make(set_type)
Create an empty set of any type but hash_private.
set set_add_element(set, const set, const void *)
statement ordering_to_statement(int o)
Get the statement associated to a given ordering.
void print_statement_set(FILE *, set)
statement.c
void print_parallel_statement(statement)
void print_statement(statement)
Print a statement on stderr.
void safe_print_statement(statement)
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
#define statement_block_p(stat)
entity entity_empty_label(void)
void print_entities(list l)
bool thread_safe_variable_p(entity v)
list load_statement_enclosing_loops(statement)
#define reference_variable(x)
#define instruction_loop(x)
#define statement_extensions(x)
#define instruction_call_p(x)
#define statement_declarations(x)
#define statement_instruction(x)
#define statement_decls_text(x)
@ is_execution_sequential
#define statement_undefined_p(x)
#define statement_number(x)
#define statement_undefined
#define STATEMENT(x)
STATEMENT.
bool rice_distribute_only
to know if do loop parallelization must be done
#define INSERT_AT_END(bl, el, c)
a macro to insert an element at the end of a list.
statement MakeLoopAs(statement old_loop_statement, tag seq_or_par, statement body)
This function creates a new loop whose characteristics (index, bounds, ...) are similar to those of o...
static bool variable_private_to_loop_p(list loops, entity var)
Check if a variable is private to loop nest.
entity current_module_entity
FI: I did not know this was still used...
bool contains_level_l_dependence(scc s, set region, int level)
s is a strongly connected component for which a DO loop is being produced.
static bool AK_ignore_this_vertex(set region, vertex v)
bool strongly_connected_p(scc s, int l)
this function returns true if scc s is stronly connected at level l, i.e.
statement find_level_l_loop_statement(scc s, int l)
s is a strongly connected component which is analyzed at level l.
statement MakeNestOfStatementList(int l, int nbl, list *lst, list loops, list *block, list *eblock, bool task_parallelize_p)
int statement_imbrication_level(statement st)
statement IsolatedStatement(scc s, int l, bool task_parallelize_p)
If the isolated statement is a CALL and is not a CONTINUE, regenerate the nested loops around it.
statement ConnectedStatements(graph g, scc s, int l, bool task_parallelize_p)
BB: ConnectedStatements() is called when s contains more than one vertex or one vertex dependent upon...
statement CodeGenerate(statement __attribute__((unused)) stat, graph g, set region, int l, bool task_parallelize_p)
This function implements Allen & Kennedy's algorithm.
static bool AK_ignore_this_successor(vertex __attribute__((unused)) v, set region, successor su, int level)
statement MakeNestOfParallelLoops(int l, cons *loops, statement body, bool task_parallelize_p)
this function creates a nest of parallel loops around an isolated statement whose iterations may exec...
static bool AK_ignore_this_level(dg_arc_label dal, int level)
bool ignore_this_conflict(vertex v1, vertex v2, conflict c, int l)
This function checks if conflict c between vertices v1 and v2 should be ignored at level l.
int enclosing
This is an horrendous hack.
void set_sccs_drivers(bool(*)(set, vertex), bool(*)(vertex, set, successor, int))
scc.c
void reset_sccs_drivers(void)
list FindAndTopSortSccs(graph, set, int)
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.