25 #include "pips_config.h"
103 #define Psysteme_undefined SC_UNDEFINED
126 #define DG_SEMANTICS 3
251 pips_debug(1,
"Computing Rice dependence graph for %s\n", mod_name);
260 "Space for chains: %d bytes\n",
263 "Space for obj_table: %d bytes\n",
272 "Space for chains's copy: %d bytes\n",
275 "Space for obj_table: %d bytes\n",
298 pips_debug(1,
"finding enclosing loops ...\n");
302 fprintf(stderr,
"\nThe number of DOs :\n");
305 debug_on(
"QUICK_PRIVATIZER_DEBUG_LEVEL");
315 for (i = 0; i <= 4; i++) {
316 for (j = 0; j <= 2; j++) {
328 fprintf(stderr,
"\nThe results of statistique of test of dependence are:\n");
339 fprintf(stderr,
"deptype[][]");
340 for (i = 0; i <= 4; i++)
341 for (j = 0; j <= 2; j++)
343 fprintf(stderr,
"\nconstdep[][]");
344 for (i = 0; i <= 4; i++)
345 for (j = 0; j <= 2; j++)
359 for (i = 0; i < 18; i++)
369 fprintf(stderr,
"updated graph\n");
458 fprintf(stderr,
"[rdg_loop] applied on region:\n");
466 "[rdg_loop] skipping loop %td (but recursing)\n",
569 pips_debug(1,
"computing execution contexts\n");
576 fprintf(stderr,
"The list of loop variants is :\n");
625 fprintf(stderr,
" \nThis dependence has been computed.\n");
657 pips_debug (4,
"looking for the opposite dependence");
677 if(e1bis == e2 && e2bis == e1) {
681 pcs2s1 =
CDR(pcs2s1);
721 debug(4,
"",
"\nThe dependence (s1,e1)-->(s2,e2)"
722 " must be removed. \n");
728 debug(4,
"",
"\nUpdating the dependence (s1,e1)-->(s2,e2)\n");
739 if(levelsop ==
NIL) {
740 debug(4,
"",
"\nThe dependence (s2,e2)-->(s1,e1)"
741 " must be removed.\n");
747 if(pchead == pchead1)
773 debug(4,
"",
"\nUpdating the dependence (s2,e2)-->(s1,e1)\n");
786 if(true_conflicts !=
NIL) {
919 _int i, cl, dims, ty;
939 "%s and %s\nDependence assumed\n",
967 for (i = 1; i <= cl; i++)
974 for (i = 1; i <= cl; i++)
1015 if(*levelsop !=
NIL) {
1027 if(levels !=
NIL || *levelsop !=
NIL) {
1043 fprintf(stderr,
"\nThis test is exact! \n");
1045 fprintf(stderr,
"\nTest not exact : "
1046 "non-exact elimination of equation!");
1048 fprintf(stderr,
"\nTest not exact : "
1049 "non-exact elimination of F-M!");
1062 for (i = 1; i <= cl; i++)
1078 for (i = 1; i <= cl; i++)
1084 *levelsop = levels1;
1168 volatile Psysteme dep_syst_op = SC_UNDEFINED;
1172 Pbase volatile tmp_base;
1187 pips_debug(6,
"loop variants after removing loop indices :\n");
1198 pips_debug(4,
"context system not feasible\n");
1230 fprintf(stderr,
"\ninitial system is:\n");
1241 pips_debug(4,
"initial normalized system not feasible\n");
1251 if(
TestDiCnst(dep_syst, cl,
s1, ef1, s2, ef2) ==
true) {
1287 if(l <= 0 || l > cl)
1290 dep_syst =
sc_rn(dep_syst_base);
1294 "projected system by sc_proj_optim_on_di() is not feasible\n");
1307 fprintf(stderr,
"projected system is:\n");
1316 pips_debug(4,
"projected system not feasible\n");
1324 fprintf(stderr,
"normalised projected system is:\n");
1326 fprintf(stderr,
"The list of DiIncNonCons is :\n");
1336 if(dep_syst != NULL) {
1337 while(DiIncNonCons != NULL) {
1341 di = DiIncNonCons->
var;
1346 DiIncNonCons = DiIncNonCons->
succ;
1352 "normalised projected system after DiIncNonCons elimination is:\n");
1381 debug(4,
"",
"\nComputes the levels and DC for dep: (s1,e1)->(s2,e2)\n");
1382 fprintf(stderr,
"\nThe distance system for dep is:\n");
1390 dep_syst1 =
sc_dup(dep_syst);
1393 dep_syst1->
base = b;
1421 list l_tmp = levels;
1424 pips_debug(5,
"dependence cone not feasible\n");
1425 MAP(
INT, ll, {
if (ll == cl+1)
ok =
true;}, l_tmp);
1428 pips_debug(5,
"innermost level found and kept\n");
1431 pips_debug(5,
"innermost level not found, no dependences");
1444 fprintf(stderr,
"\nThe levels for dep (s1,s2) are:");
1451 fprintf(stderr,
"\nThe lexico-positive dependence cone for"
1452 " dep (s1,s2) :\n");
1455 fprintf(stderr,
"\nLexico-positive dependence cone"
1456 " doesn't exist for dep (s1,s2).\n");
1463 pips_debug(4,
"Computes the levels and DC for dep_op: (s2,e2)->(s1,e1)\n");
1465 fprintf(stderr,
"\nThe invers distance system for dep_op is:\n");
1469 dep_syst2 =
sc_dup(dep_syst_op);
1472 dep_syst2->
base = b;
1477 if(*levelsop !=
NIL) {
1489 list l_tmp = *levelsop;
1492 MAP(
INT, ll, {
if (ll == cl+1)
ok =
true;}, l_tmp);
1506 fprintf(stderr,
"\nThe levels for dep_op (s2,s1) is:");
1513 fprintf(stderr,
"\nThe lexico-positive Dependence "
1514 "cone for dep_op (s2,s1):\n");
1517 fprintf(stderr,
"\nLexico-positive dependence cone "
1518 "does not exist for dep_op (s2,s1).\n");
1523 if(levels ==
NIL && *levelsop ==
NIL) {
1586 list s2_enc_loops) {
1591 pips_assert(
"build_and_test_dependence_context", SC_UNDEFINED_P(*psc_dep));
1596 if(SC_UNDEFINED_P(sc1) && SC_UNDEFINED_P(sc2)) {
1599 if(SC_UNDEFINED_P(sc1))
1609 *psc_dep = SC_EMPTY;
1611 "first initial normalized system sc1 not feasible\n");
1616 debug(6,
"",
"Initial system sc1 before restrictions : \n");
1637 if(SC_UNDEFINED_P(sc2))
1655 *psc_dep = SC_EMPTY;
1657 "second initial normalized system not feasible\n");
1662 debug(6,
"",
"Initial system sc2 before restrictions : \n");
1687 debug(6,
"",
"Initial systems after restrictions : \n");
1694 for (pc = s2_enc_loops, l = 1; pc !=
NIL; pc =
CDR(pc), l++) {
1723 for (pc = llv, l = 1; pc !=
NIL; pc =
CDR(pc), l++) {
1737 "\ndependence context is:\n");
1775 while(pc1 !=
NIL && pc2 !=
NIL) {
1791 for (pc = s2_enc_loops, l = 1; pc !=
NIL; pc =
CDR(pc), l++) {
1804 for (pc = llv, l = 1; pc !=
NIL; pc =
CDR(pc), l++) {
1825 sc_add_eg(*psc_dep, c);
1834 if(pc1 !=
NIL || pc2 !=
NIL) {
1840 " of different lengths for variable \"%s\".\n",
1847 Pbase cb = sc_base(*psc_dep);
1850 sc_base(*psc_dep) = nb;
1896 for (pc = s1_enc_loops, l = 1; pc !=
NIL; pc =
CDR(pc), l++) {
1921 sc_add_eg(*psc_dep, pc);
1939 sc_add_eg(*psc_dep, pc);
2005 bool all_level_founds =
false;
2007 pips_debug(7,
"maximum common level (cl): %d\n", cl);
2009 for (l = 1; !all_level_founds && l <= cl; l++) {
2012 int IsPositif, IsNegatif, IsNull, NotPositif;
2018 pips_debug(7,
"current level: %td, variable: %s\n",
2023 pips_debug(7,
"sc_minmax_of_variable_optim: non feasible system\n");
2024 all_level_founds =
true;
2039 IsPositif ?
"positive" : (IsNegatif ?
"negative"
2045 all_level_founds =
true;
2052 all_level_founds =
true;
2056 if(!IsNull && !NotPositif) {
2061 if(!all_level_founds && l <= cl - 1) {
2062 pips_debug(7,
"forcing variable %s to 0 (l < cl)\n",
2087 pips_debug(7,
"adding innermost level %td\n", l);
2098 Psysteme volatile sc_env = SC_UNDEFINED;
2099 Ptsg volatile sg_env = NULL;
2104 if(SC_UNDEFINED_P(dep_sc))
2108 n = dep_sc->dimension;
2111 for (i = 1; i <= n; i++) {
2117 for (j = 1,
b1 = b; j <= i - 1; j++,
b1 =
b1->succ) {
2121 sc_add_eg(sub_sc,pc);
2127 sc_add_ineg(sub_sc,pc);
2130 fprintf(stderr,
"\nInitial sub lexico-positive dependence system:\n");
2142 pips_debug(7,
"sub lexico-positive dependence system not feasible\n");
2153 pips_debug(7,
"normalized system not feasible\n");
2159 fprintf(stderr,
"Normalized sub lexico-positive dependence system :\n");
2172 fprintf(stderr,
"Dependence system of the enveloppe of subs "
2173 "lexico-positive dependence:\n");
2176 if(!SC_UNDEFINED_P(sc_env) && !
sc_rn_p(sc_env)) {
2178 fprintf(stderr,
"Enveloppe of the subs lexico-positive "
2179 "dependence cones:\n");
2183 sg_env = (
Ptsg)NULL;
2190 if(!SC_UNDEFINED_P(sc_env) && sc_dimension(sc_env) != 0) {
2239 for (l = 1; l <= cl; l++) {
2243 bool success_p =
true;
2275 filename =
"resulttestfast";
2278 filename =
"resulttestfull";
2281 filename =
"resulttestseman";
2299 " %d %d %d %d %d %d %d %d %d %d",
2310 for (i = 0; i <= 4; i++)
2311 for (j = 0; j <= 2; j++)
2313 for (i = 0; i <= 4; i++)
2314 for (j = 0; j <= 2; j++)
2317 " %d %d %d %d %d %d %d %d %d %d %d",
2329 for (i = 0; i < 18; i++)
2346 debug_on(
"QUICK_PRIVATIZER_DEBUG_LEVEL");
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
void free_conflict(conflict p)
cone make_cone(list a1, Ptsg a2)
sccflags make_sccflags(scc a1, intptr_t a2, intptr_t a3, intptr_t a4)
bool graph_consistent_p(graph p)
void free_successor(successor p)
graph copy_graph(graph p)
GRAPH.
bool entity_all_locations_p(entity e)
test if an entity is the top of the lattice
#define int_to_value(i)
end LINEAR_VALUE_IS_INT
#define value_notzero_p(val)
#define value_zero_p(val)
#define value_product(v, w)
void fprint_string_Value(FILE *, char *, Value)
Pbase base_add_variable(Pbase b, Variable var)
Pbase base_add_variable(Pbase b, Variable v): add variable v as a new dimension to basis b at the end...
bool vect_in_basis_p(Pvecteur v, Pbase b)
Pvecteur vect_in_basis_p(Pvecteur v, Pbase b): check that all coordinates in v are in b,...
Pbase base_union(Pbase b1, Pbase b2)
Pbase base_union(Pbase b1, Pbase b2): compute a new basis containing all elements of b1 and all eleme...
static bool chains(char *module_name, enum chain_type use)
Compute chain dependence for a module according different kinds of store-like effects.
Ptsg sc_to_sg_chernikova(Psysteme sc)
chernikova_mulprec.c
void vect_debug(Pvecteur v)
constraint.c
void sc_syst_debug(Psysteme s)
constraint_to_text.c
statement_mapping contexts_mapping_of_nest(statement stat)
contexts.c
#define COEFF_CST(c)
int COEFF_CST(Pcontrainte c): terme constant d'une contrainte
Pcontrainte contrainte_make(Pvecteur pv)
Pcontrainte contrainte_make(Pvecteur pv): allocation et initialisation d'une contrainte avec un vecte...
bool egalite_normalize(Pcontrainte)
bool egalite_normalize(Pcontrainte eg): reduction d'une equation diophantienne par le pgcd de ses coe...
bool contrainte_constante_p(Pcontrainte)
bool contrainte_constante_p(Pcontrainte c): test de contrainte triviale sans variables (ie du type 0<...
struct _newgen_struct_dg_arc_label_ * dg_arc_label
#define CONFLICT(x)
CONFLICT.
#define dg_vertex_label_sccflags(x)
#define dg_arc_label_conflicts(x)
#define conflict_source(x)
#define conflict_undefined
struct _newgen_struct_dg_vertex_label_ * dg_vertex_label
#define dg_arc_label_undefined
#define region
simulation of the type region
void set_cumulated_rw_effects(statement_effects)
list load_cumulated_rw_effects_list(statement)
void reset_cumulated_rw_effects(void)
list words_effect(effect)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
entity effect_entity(effect)
cproto-generated files
#define action_write_p(x)
FILE * safe_fopen(const char *filename, const char *what)
int safe_fclose(FILE *stream, const char *filename)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
int current_shared_obj_table_size(void)
for debug
int gen_allocated_memory(gen_chunk *obj)
re-entry is automatic for this function.
#define successor_vertex(x)
#define successor_undefined
#define successor_arc_label(x)
struct _newgen_struct_graph_ * graph
#define vertex_vertex_label(x)
#define vertex_successors(x)
#define newgen_arc_label(p)
#define SUCCESSOR(x)
SUCCESSOR.
#define graph_vertices(x)
#define successor_arc_label_(x)
#define CONTROL_MAP(ctl, code, c, list)
Macro to walk through all the controls reachable from a given control node of an unstructured.
void reset_current_module_entity(void)
Reset the current module entity.
void reset_current_module_statement(void)
Reset the current module statement.
statement set_current_module_statement(statement)
Set the current module statement.
statement get_current_module_statement(void)
Get the current module statement.
entity set_current_module_entity(entity)
static.c
entity get_current_module_entity(void)
Get the entity of the current module.
set distributable_loop(statement l)
this functions checks if Kennedy's algorithm can be applied on the loop passed as argument.
set region_of_loop(statement l)
this function returns the set of all statements belonging to the given loop even if the loop contains...
int loop_increment_value(loop l)
void clean_enclosing_loops(void)
statement_mapping loops_mapping_of_statement(statement stat)
void gen_remove(list *cpp, const void *o)
remove all occurences of item o from list *cpp, which is thus modified.
#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)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#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 list_undefined
Undefined list definition :-)
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
#define DB_PUT_MEMORY_RESOURCE(res_name, own_name, res_val)
conform to old interface.
loop statement_loop(statement)
Get the loop of a statement.
bool statement_loop_p(statement)
bool statement_possible_less_p(statement, statement)
void hash_warn_on_redefinition(void)
these function set the variable should_i_warn_on_redefinition to the value true or false
statement vertex_to_statement(vertex v)
Vertex_to_statement looks for the statement that is pointed to by vertex v.
static statement mod_stat
We want to keep track of the current statement inside the recurse.
int vect_size(Pvecteur v)
package vecteur - reductions
void * memset(void *str, int c, size_t len)
memset.c – set an area of memory to a given value Copyright (C) 1991, 2003, 2009-2011 Free Software F...
#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 pips_internal_error
void debug(const int the_expected_debug_level, const char *calling_function_name, const char *a_message_format,...)
ARARGS0.
void print_arguments(list args)
#define DEFINE_CURRENT_MAPPING(name, type)
string concatenate(const char *,...)
Return the concatenation of the given strings.
#define same_string_p(s1, s2)
bool set_belong_p(const set, const void *)
hash_table set_ordering_to_statement(statement s)
To be used instead of initialize_ordering_to_statement() to make sure that the hash table ots is in s...
void reset_ordering_to_statement(void)
Reset the mapping from ordering to statement.
string db_get_current_workspace_directory(void)
rule find_rule_by_resource(const char *rname)
This function returns the active rule to produce resource rname.
Psysteme sc_enveloppe_chernikova(Psysteme, Psysteme)
void print_statement_set(FILE *, set)
statement.c
#define RICEDG_PROVIDE_STATISTICS
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
void quick_privatize_graph(graph dep_graph)
quick_privatize.c
#define NORMALIZE_EXPRESSION(e)
#define unstructured_control
After the modification in Newgen: unstructured = entry:control x exit:control we have create a macro ...
#define is_instruction_block
soft block->sequence transition
#define instruction_block(i)
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
entity local_name_to_top_level_entity(const char *n)
This function try to find a top-level entity from a local name.
bool fortran_module_p(entity m)
Test if a module is in Fortran.
list load_statement_enclosing_loops(statement)
bool pointer_type_p(type)
Check for scalar pointers.
bool entity_atomic_reference_p(entity)
Any reference r such that reference_variable(r)==e accesses all bytes (or bits) allocated to variable...
void set_enclosing_loops_map(statement_mapping)
bool entity_integer_scalar_p(entity)
for variables (like I), not constants (like 1)! use integer_constant_p() for constants
#define normalized_linear_p(x)
#define instruction_loop_p(x)
#define reference_variable(x)
#define EXPRESSION(x)
EXPRESSION.
@ is_instruction_unstructured
@ is_instruction_whileloop
@ is_instruction_expression
#define instruction_tag(x)
#define transformer_relation(x)
#define reference_indices(x)
#define instruction_forloop(x)
#define instruction_whileloop(x)
#define whileloop_body(x)
#define statement_declarations(x)
#define statement_instruction(x)
#define control_statement(x)
#define instruction_test(x)
#define statement_number(x)
#define normalized_linear(x)
#define predicate_system(x)
#define whileloop_undefined
#define instruction_unstructured(x)
#define statement_undefined
#define STATEMENT(x)
STATEMENT.
#define forloop_undefined
static list TestDiVariables(Psysteme, int, statement, effect, statement, effect)
bool rice_full_dependence_graph(char *mod_name)
static void rdg_unstructured(unstructured)
STATIC FUNCTION DECLARATIONS
bool rice_semantics_dependence_graph(char *mod_name)
static void dependence_system_add_lci_and_di(Psysteme *, list, Pvecteur *)
static void dependence_system_add_lci_and_di(Psysteme *psc_dep, list s1_enc_loops,...
int NbrArrayDepInit
Dependence Graph computation for Allen & Kennedy algorithm.
static list TestDependence(list, Psysteme, statement, effect, reference, list, Psysteme, statement, effect, reference, list, Ptsg *, list *, Ptsg *)
static list TestDependence(list n1, n2, Psysteme sc1, sc2, statement s1, s2, effect ef1,...
static list TestCoupleOfEffects(statement, effect, statement, effect, list, Ptsg *, list *, Ptsg *)
DEPENDENCE TEST
static list loop_variant_list(statement)
int NbrTestDiCnst
by sc_normalize()
static bool rice_dependence_graph(char *)
INTERFACE FUNCTIONS
#define DG_FAST
Different types of dependence tests:
static bool build_and_test_dependence_context(reference, reference, Psysteme, Psysteme, Psysteme *, list, list)
static bool build_and_test_dependence_context(reference r1, r2, Psystem sc1, sc2, *psc_dep,...
static bool TestDiCnst(Psysteme, int, statement, effect, statement, effect)
static void rdg_loop(statement)
static Ptsg dependence_cone_positive(Psysteme)
Ptsg dependence_cone_positive(Psysteme dept_syst)
bool rice_fast_dependence_graph(char *mod_name)
void writeresult(char *mod_name)
bool rice_regions_dependence_graph(char *mod_name)
bool is_test_exact
or counting the number of F-M complexity less than 16.
list TestCoupleOfReferences(list n1, Psysteme sc1 __attribute__((unused)), statement s1, effect ef1, reference r1, list n2, Psysteme sc2 __attribute__((unused)), statement s2, effect ef2, reference r2, list llv, Ptsg *gs __attribute__((unused)), list *levelsop __attribute__((unused)), Ptsg *gsop __attribute__((unused)))
graph compute_dg_on_statement_from_chains_in_place(statement s, graph chains)
static void rice_update_dependence_graph(statement, set)
Update of dependence graph.
static bool gcd_and_constant_dependence_test(reference, reference, list, list, Psysteme *)
static bool gcd_and_constant_dependence_test(references r1, r2, list llv, s2_enc_loops,...
static void rdg_statement(statement)
graph compute_dg_on_statement_from_chains(statement s, graph chains)
static graph dg
to map statements to enclosing loops
void print_dependence_cone(FILE *, Ptsg, Pbase)
Psysteme sc_invers(Psysteme)
Psysteme sc_invers(Psysteme ps): calcul un systeme des contraintes qui est l'invers du systeme initia...
Pbase MakeDibaseinorder(int)
Pbase MakeDibaseinorder(int n) make a base of D#1 ...
int sc_proj_optim_on_di_ofl(int, Psysteme *)
int sc_proj_optim_on_di_ofl(cl, sc)
void set_context_map(statement_mapping)
bool sc_faisabilite_optim(Psysteme)
bool sc_faisabilite_optim (Psysteme sc) :
void sc_add_di(int, entity, Psysteme, int)
void prettyprint_dependence_graph(FILE *, statement, graph)
Print all edges and arcs.
void ResetLoopCounter(void)
entity GetDiVar(int)
This functions looks up a di variable of nesting level l in table DiVars.
int dep_type(action, action)
int dep_type(action ac1,action ac2) This function test the type of the dependence.
int DiVarLevel(entity)
this function returns the nesting level of a given di variable e.
bool sc_minmax_of_variable_optim(Psysteme volatile, Variable, Value *, Value *)
void sc_minmax_of_variable_optim(Psysteme ps, Variable var, Value *pmin, *pmax): examine un systeme p...
void sc_add_dsi(int, entity, Psysteme)
Psysteme load_statement_context(statement)
void reset_context_map(void)
int FindMaximumCommonLevel(cons *, cons *)
entity MakeLoopCounter(void)
Create a new loop counter variable.
struct Ssysteme * Psysteme
bool sc_consistent_p(Psysteme sc)
bool sc_consistent_p(Psysteme sc): check that sc is well defined, that the numbers of equalities and ...
bool sc_weak_consistent_p(Psysteme sc)
check that sc is well defined, that the numbers of equalities and inequalities are consistent with th...
bool sc_rn_p(Psysteme sc)
bool sc_rn_p(Psysteme sc): check if the set associated to sc is the whole space, rn
Psysteme sc_empty(Pbase b)
Psysteme sc_empty(Pbase b): build a Psysteme with one unfeasible constraint to define the empty subsp...
Psysteme sc_rn(Pbase b)
Psysteme sc_rn(Pbase b): build a Psysteme without constraints to define R^n, where n is b's dimension...
void sc_creer_base(Psysteme ps)
void sc_creer_base(Psysteme ps): initialisation des parametres dimension et base d'un systeme lineair...
void sc_rm(Psysteme ps)
void sc_rm(Psysteme ps): liberation de l'espace memoire occupe par le systeme de contraintes ps;
Pbase sc_to_minimal_basis(Psysteme ps)
creation d'une base contenant toutes les variables apparaissant avec des coefficients non-nuls dans l...
Psysteme sc_new(void)
Psysteme sc_new(): alloue un systeme vide, initialise tous les champs avec des valeurs nulles,...
bool sc_empty_p(Psysteme sc)
bool sc_empty_p(Psysteme sc): check if the set associated to sc is the constant sc_empty or not.
Psysteme sc_dup(Psysteme ps)
Psysteme sc_dup(Psysteme ps): should becomes a link.
void sc_force_variable_to_zero(Psysteme ps, Variable var)
void sc_force_variable_to_zero(Psysteme ps, Variable var): force la variable var a prendre la valeur ...
bool sc_value_of_variable(Psysteme ps, Variable var, Value *pval)
bool sc_value_for_variable(Psysteme ps, Variable var, Value *pval): examine les egalites du systeme p...
bool sc_integer_feasibility_ofl_ctrl(Psysteme sc, int ofl_ctrl, bool ofl_res)
Value b1
booleen indiquant quel membre est en cours d'analyse
Psysteme sc_fusion(Psysteme s1, Psysteme s2)
package sc
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
Psysteme sc_restricted_to_variables_transitive_closure(Psysteme sc, Pbase variables)
for an improved dependence test (Beatrice Creusillet)
Psysteme sc_normalize(Psysteme ps)
Psysteme sc_normalize(Psysteme ps): normalisation d'un systeme d'equation et d'inequations lineaires ...
static int variables[MAX_VAR]
Psysteme sc_elim_var(Psysteme sc, Variable v)
package sur les systemes de contraintes sc
void sc_chg_var(Psysteme s, Variable v_old, Variable v_new)
void sc_chg_var(Psysteme s, Variable v_old, Variable v_new) this function replace the variable v_old ...
transformer load_statement_precondition(statement)
void reset_precondition_map(void)
void set_precondition_map(statement_mapping)
struct type_sg * Ptsg
Representation d'un systeme generateur par trois ensembles de sommets de rayons et de droites.
#define sg_empty(sg)
Test for an empty generating system, which corresponds to an empty set.
#define SG_UNDEFINED_P(sg)
Ptsg sg_new()
Ptsg sg_new(): allocation d'un systeme generateur et initialisation a la valeur ensemble vide.
void sg_rm(Ptsg sg)
void sg_rm(Ptsg sg): liberation de l'espace memoire occupe par un systeme generateur
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
Representation d'un systeme generateur par trois ensembles de sommets de rayons et de droites.
void print_words(FILE *fd, cons *lw)
A gen_chunk is used to store every object.
#define TCST
VARIABLE REPRESENTANT LE TERME CONSTANT.
struct Svecteur * Pvecteur
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....
#define BASE_NULLE
MACROS SUR LES BASES.
#define VECTEUR_UNDEFINED_P(v)
Pvecteur vect_dup(Pvecteur v_in)
Pvecteur vect_dup(Pvecteur v_in): duplication du vecteur v_in; allocation de et copie dans v_out;.
Pbase base_dup(Pbase b)
Pbase base_dup(Pbase b) Note: this function changes the value of the pointer.
Pvecteur vect_new(Variable var, Value coeff)
Pvecteur vect_new(Variable var,Value coeff): allocation d'un vecteur colineaire au vecteur de base va...
void vect_rm(Pvecteur v)
void vect_rm(Pvecteur v): desallocation des couples de v;
Pvecteur vect_substract(Pvecteur v1, Pvecteur v2)
Pvecteur vect_substract(Pvecteur v1, Pvecteur v2): allocation d'un vecteur v dont la valeur est la di...
void vect_add_elem(Pvecteur *pvect, Variable var, Value val)
void vect_add_elem(Pvecteur * pvect, Variable var, Value val): addition d'un vecteur colineaire au ve...
Value vect_coeff(Variable var, Pvecteur vect)
Variable vect_coeff(Variable var, Pvecteur vect): coefficient de coordonnee var du vecteur vect —> So...
void vect_chg_var(Pvecteur *ppv, Variable v_old, Variable v_new)
void vect_chg_var(Pvecteur *ppv, Variable v_old, Variable v_new) replace the variable v_old by v_new