utils.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "union.h"
#include "matrice.h"
#include "matrix.h"
#include "ri.h"
#include "ri-util.h"
#include "constants.h"
#include "graph.h"
#include "paf_ri.h"
#include "text.h"
#include "text-util.h"
#include "misc.h"
#include "static_controlize.h"
#include "paf-util.h"
#include "prgm_mapping.h"

Include dependency graph for utils.c:

Go to the source code of this file.

Typedefs
typedef dfg_vertex_label	vertex_label
	Internal variables More...
typedef dfg_arc_label	arc_label
typedef bool(*	argh) (Pvecteur *, Pvecteur *)
	======================================================================== More...

Functions
list	insert_sort (list l, bool(*compare_obj)())
	======================================================================== More...
bool	is_index_coeff_p (entity e)
	======================================================================== More...
bool	compare_coeff (chunk *c1, chunk *c2)
	======================================================================== More...
bool	compare_nodes_dim (chunk *n1, chunk *n2)
	======================================================================== More...
bool	compare_dfs_weight (chunk *d1, chunk *d2)
	======================================================================== More...
bool	compare_unks_frenq (chunk *e1, chunk *e2)
	======================================================================== More...
entity	make_coeff (string prefix, int n)
	======================================================================== More...
entity	find_or_create_coeff (string prefix, int n)
	======================================================================== More...
list	rm_non_x_var (list l)
	======================================================================== More...
list	unify_lists (list l1, list l2)
	======================================================================== More...
Psysteme	new_elim_var_with_eg (Psysteme ps, list *init_l, list *elim_l)
	======================================================================== More...
Psysteme	plc_elim_var_with_eg (Psysteme ps, list *init_l, list *elim_l)
	======================================================================== More...
int	count_implicit_equation (Psysteme ps)
	======================================================================== More...
list	put_source_ind (list le)
	======================================================================== More...
Ppolynome	apply_farkas (Ppolynome F, Psysteme D, list *L, int *count_lambdas)
list	get_graph_dataflows (graph g)
	======================================================================== More...
list	get_stmt_index_coeff (int stmt, hash_table StoL)
	======================================================================== More...
Psysteme	completer_base (Psysteme sys, list var_l, list par_l)
	======================================================================== More...
list	diff_lists (list l1, list l2)
	======================================================================== More...
bool	vecteurs_libres_p (Psysteme sys, Pbase v_base, Pbase c_base)
	======================================================================== More...
Psysteme	append_eg (Psysteme M1, Psysteme M2)
	======================================================================== More...
void	di_polynome_var_subst_null (Ppolynome *pp, entity var)
	======================================================================== More...
Psysteme	nullify_factors (Ppolynome *pp, list var_l, bool with_remnants)
	======================================================================== More...
bool	is_broadcast_p (dataflow df)
	======================================================================== More...
int	communication_dim (dataflow df)
	======================================================================== More...
bool	is_reduction_p (dataflow df)
	======================================================================== More...
bool	is_shift_p (dataflow df)
	======================================================================== More...
void	my_substitute_var_with_vec (Psysteme ps, entity var, int val, Pvecteur vec)
	=========================================================================== More...
Pvecteur	old_prototype_factorize (Ppolynome pp, Variable var)
	======================================================================== More...

Variables
char	vcid_prgm_mapping_utils [] = "$Id: utils.c 23065 2016-03-02 09:05:50Z coelho $"
list	prgm_parameter_l
	lint More...

Typedef Documentation

arc_label

typedef dfg_arc_label arc_label

Definition at line 94 of file utils.c.

argh

typedef bool(* argh) (Pvecteur *, Pvecteur *)

========================================================================

Ppolynome apply_farkas(Ppolynome F, Psysteme D, list *L, int *count_lambdas) returns the affine from of farkas lemma computed from the polynome "F" (the affine form) and the domain of its variables "ps_dom".

Farkas Lemma:

Let D be a non empty polyhedron defined by n affine inequalities: Ik(x) >= 0, k in 1,..,n

Then an affine form F is a non negative everywhere in D iff it is a positive affine combination of the above inequalities: F(x) >= 0 in D <=> F(x) == L0 + L1.I1(x) + .. + Ln.In(x) with Lk >= 0, k in 1,..,n

Here, *L" is the list (L0,..,Ln). If we note P(x) = L0 + L1.I1(x) + .. + Ln.In(x), the polynome returned is the Farkas polynome: FP = F(x) - P(x)

We also have to add the structure parameters that do not appear in D and that are in the global var "prgm_parameter_l". For instance, if "p" (in "prgm_parameter_l") does not appear in D, we'll have: P(x) = L0 + L1.I1(x) + .. + Ln.In(x) + Ln+1.p and "*L" will be (L0,..,Ln,Ln+1)

In the following code, variable "P" is the opposite of our P(x). In doing so, we'll be able to simplified the final calculus (F(x) - P(x)) by an addition.

Definition at line 667 of file utils.c.

vertex_label

typedef dfg_vertex_label vertex_label

Internal variables

Local defines

Definition at line 93 of file utils.c.

Function Documentation

append_eg()

Psysteme append_eg	(	Psysteme	M1,
		Psysteme	M2
	)

========================================================================

Definition at line 946 of file utils.c.

{
  Pcontrainte pc1, pc2, prec;
  Pvecteur pv;
 
  if(M1 == NULL)
    return(M2);
  if(M2 == NULL)
    return(M1);
 
  pc1 = M1->egalites;
  pc2 = M2->egalites;
  for(prec = NULL; pc1 != NULL; pc1 = pc1->succ)
    prec = pc1;
 
  if(prec == NULL)
    return(M2);
 
  prec->succ = pc2;
  M1->nb_eq += M2->nb_eq;
 
  pv = M1->base;
  M1->base = NULL;
  vect_rm(pv);
  sc_creer_base(M1);
 
  return(M1);
}

References M1, M2, sc_creer_base(), Scontrainte::succ, and vect_rm().

Referenced by base_complete(), completer_base(), completer_n_base(), cutting_conditions(), and partial_broadcast_coefficients().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_farkas()

Ppolynome apply_farkas	(	Ppolynome	F,
		Psysteme	D,
		list *	L,
		int *	count_lambdas
	)

Constant term: L0

We associate to each equation or inequation a different coefficient, so the addition is never simplified, it just put a few monomes to the end of "P", i.e. "last_P". We do not used "polynome_add()" because this function looks for similar monomes.

An equality (v == 0) is also two inequalities (v >= 0, v <= 0)

We add to (-P) the parameters that do not appear in D

pu_is_inferior_var is not implemented and does not match prototype...

FP = F + (-P) We are sure that F-P can not be simplified, i.e. that there are similar monomes; this is because each monome of P has a variable that never appear outside of P.

Definition at line 669 of file utils.c.

{
  Ppolynome FP, pp_v, P, last_P;
  int cl = *count_lambdas;
  entity nl;
  list local_l = NIL, params_in_D, l, ll;
  Pcontrainte pc;
 
  nl = find_or_create_coeff(LAMBD_COEFF, cl++);
  local_l = CONS(ENTITY, nl, local_l);
 
  /* Constant term: L0 */
  P = make_polynome(-1.0, (Variable) nl, 1);
  last_P = P;
 
  /* We associate to each equation or inequation a different coefficient, so
   * the addition is never simplified, it just put a few monomes to the end
   * of "P", i.e. "last_P". We do not used "polynome_add()" because this
   * function looks for similar monomes.
   */
  if(D != NULL) {
    for(pc = D->inegalites; pc != NULL; pc = pc->succ) {
      Pvecteur pv = pc->vecteur;
 
      nl = find_or_create_coeff(LAMBD_COEFF, cl++);
      local_l = CONS(ENTITY, nl, local_l);
 
      pp_v = vecteur_mult(pv, vect_new((Variable) nl, 1));
 
      for(last_P->succ = pp_v; last_P->succ != NULL; last_P = last_P->succ) {}
    }
 
    /* An equality (v == 0) is also two inequalities (v >= 0, v <= 0) */
    for(pc = D->egalites; pc != NULL; pc = pc->succ) {
      Pvecteur pv = pc->vecteur;
 
      nl = find_or_create_coeff(LAMBD_COEFF, cl++);
      local_l = CONS(ENTITY, nl, local_l);
 
      pp_v = vecteur_mult(pv, vect_new((Variable) nl, 1));
 
      for(last_P->succ = pp_v; last_P->succ != NULL; last_P = last_P->succ) {}
 
      nl = find_or_create_coeff(LAMBD_COEFF, cl++);
      local_l = CONS(ENTITY, nl, local_l);
 
      pp_v = vecteur_mult(pv, vect_new((Variable) nl, -1));
 
      for(last_P->succ = pp_v; last_P->succ != NULL; last_P = last_P->succ) {}
    }
  }
 
  /* We add to (-P) the parameters that do not appear in D */
  /* pu_is_inferior_var is not implemented and does not match prototype... */
  params_in_D = base_to_list(polynome_used_var(P, (argh) pu_is_inferior_var));
  for(l = gen_append(prgm_parameter_l, NIL); !ENDP(l); POP(l)) {
    bool not_found = true;
    entity p = ENTITY(CAR(l));
    for(ll = params_in_D; !ENDP(ll) && (not_found); POP(ll)) {
      if( same_entity_p(p, ENTITY(CAR(ll))) )
        not_found = false;
    }
    if(not_found) {
      nl = find_or_create_coeff(LAMBD_COEFF, cl++);
      local_l = CONS(ENTITY, nl, local_l);
 
      pp_v = vecteur_mult(vect_new((Variable) nl, -1),
                          vect_new((Variable) p, 1));
 
      for(last_P->succ = pp_v; last_P->succ != NULL; last_P = last_P->succ) {}
    }
  }
 
  /* FP = F + (-P)
   * We are sure that F-P can not be simplified, i.e. that there are similar
   * monomes; this is because each monome of P has a variable that never
   * appear outside of P.
   */
  FP = P;
  last_P->succ = F;
 
  *L = local_l;
  *count_lambdas = cl;
  return(FP);
}

References base_to_list(), CAR, CONS, D, ENDP, ENTITY, F, find_or_create_coeff(), gen_append(), LAMBD_COEFF, make_polynome(), NIL, polynome_used_var(), POP, prgm_parameter_l, pu_is_inferior_var(), same_entity_p(), Scontrainte::succ, Spolynome::succ, vect_new(), Scontrainte::vecteur, and vecteur_mult().

Referenced by valuer().

Here is the call graph for this function:

Here is the caller graph for this function:

communication_dim()

int communication_dim

(

dataflow

df

)

========================================================================

int communication_dim(dataflow df): returns the number of directions vectors of the dataflow if it a broadcast or a reduction. Oterwise, returns 0.

Definition at line 1116 of file utils.c.

{
 communication com;
 predicate bp, rp;
 Psysteme ps;
 Pcontrainte pc;
 int dim = 0;
 
 com = dataflow_communication(df);
 if(com == communication_undefined)
    return(0);
 
 bp = communication_broadcast(com);
 rp = communication_reduction(com);
 if((bp == predicate_undefined) && (rp == predicate_undefined))
    return(0);
 
 if(bp == predicate_undefined)
   ps = (Psysteme) predicate_system(rp);
 else
   ps = (Psysteme) predicate_system(bp);
 
 for(pc = ps->egalites; pc != NULL; pc = pc->succ)
   dim++;
 
 return(dim);
}

References communication_broadcast, communication_reduction, communication_undefined, dataflow_communication, Ssysteme::egalites, predicate_system, predicate_undefined, and Scontrainte::succ.

Referenced by edge_weight().

Here is the caller graph for this function:

compare_coeff()

bool compare_coeff	(	chunk *	c1,
		chunk *	c2
	)

========================================================================

bool compare_coeff(c1, c2):

returns a bool saying true if "c1" is before "c2" in the lexicographic order, else FALSE. "c1" and "c2" are entities, we compare their name.

Definition at line 161 of file utils.c.

{
  return strcmp(entity_local_name((entity) c1),
         entity_local_name((entity) c2))<0;
}

References entity_local_name().

Referenced by plc_make_vvs_with_vector(), and valuer().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_dfs_weight()

bool compare_dfs_weight	(	chunk *	d1,
		chunk *	d2
	)

========================================================================

Definition at line 181 of file utils.c.

{
  extern hash_table DtfToWgh;
 
  return( (int) hash_get(DtfToWgh, (char *) d1) >
          (int) hash_get(DtfToWgh, (char *) d2) );
}

References DtfToWgh, and hash_get().

Referenced by prgm_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_nodes_dim()

bool compare_nodes_dim	(	chunk *	n1,
		chunk *	n2
	)

========================================================================

Definition at line 170 of file utils.c.

{
  extern hash_table StmtToDim;
 
  return((int) hash_get(StmtToDim, (char *) vertex_int_stmt((vertex) n1)) >
         (int) hash_get(StmtToDim, (char *) vertex_int_stmt((vertex) n2)) );
}

References hash_get(), StmtToDim, and vertex_int_stmt().

Referenced by sort_dfg_node().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_unks_frenq()

bool compare_unks_frenq	(	chunk *	e1,
		chunk *	e2
	)

========================================================================

Definition at line 192 of file utils.c.

{
  extern hash_table UnkToFrenq;
 
  return( (int) hash_get(UnkToFrenq, (char *) e1) >
          (int) hash_get(UnkToFrenq, (char *) e2) );
}

References hash_get(), and UnkToFrenq.

Referenced by sort_unknowns().

Here is the call graph for this function:

Here is the caller graph for this function:

completer_base()

Psysteme completer_base	(	Psysteme	sys,
		list	var_l,
		list	par_l
	)

========================================================================

Definition at line 832 of file utils.c.

{
  Psysteme ps = sc_dup(sys), new_ps = sc_new();
  int dim = gen_length(var_l) - sys->nb_eq;
  list l;
 
  for(l = var_l; (!ENDP(l)) && (new_ps->nb_eq < dim); POP(l)) {
    entity var = ENTITY(CAR(l));
    Pvecteur pv = vect_new((Variable) var, 1);
    Psysteme aux_ps = sc_dup(ps);
    Psysteme aux_new_ps = sc_dup(new_ps);
 
    sc_add_egalite(aux_new_ps, contrainte_make(pv));
    aux_ps = append_eg(aux_ps, aux_new_ps);
 
    if(vecteurs_libres_p(aux_ps, list_to_base(var_l), list_to_base(par_l))) {
      new_ps = aux_new_ps;
    }
    else
      sc_rm(aux_new_ps);
  }
  ps = append_eg(ps, new_ps);
  ps->base = NULL;
  sc_creer_base(ps);
  return(ps);
}

References append_eg(), Ssysteme::base, CAR, contrainte_make(), ENDP, ENTITY, gen_length(), list_to_base(), POP, sc_add_egalite(), sc_creer_base(), sc_dup(), sc_new(), sc_rm(), vect_new(), and vecteurs_libres_p().

Referenced by broadcast_conditions(), and system_inversion_restrict().

Here is the call graph for this function:

Here is the caller graph for this function:

count_implicit_equation()

int count_implicit_equation

(

Psysteme

ps

)

========================================================================

int new_count_implicit_equation(Psysteme ps): returns the number of implicit equations there are in the system "ps".

Practically, we construct a system containing all the implicit equations, then we count the number of equations (there should be no redondant equation since find_implicit_equation() normalizes its result).

See the description of find_implicit_equation().

If impl_ps is empty, then no data are communicated

Definition at line 562 of file utils.c.

{
  Psysteme impl_ps;
 
  if(ps == NULL)
    return(0);
 
  impl_ps = find_implicit_equation(ps);
 
  /* If impl_ps is empty, then no data are communicated */
  if(impl_ps == NULL)
    return(ps->nb_ineq + ps->nb_eq);
 
  if(get_debug_level() > 6) {
    fprintf(stderr, "Number of equations in Implicit system : %d\n", impl_ps->nb_eq);
  }
  return(impl_ps->nb_eq);
}

References find_implicit_equation(), fprintf(), get_debug_level(), and Ssysteme::nb_eq.

Referenced by edge_weight().

Here is the call graph for this function:

Here is the caller graph for this function:

di_polynome_var_subst_null()

void di_polynome_var_subst_null	(	Ppolynome *	pp,
		entity	var
	)

========================================================================

Definition at line 980 of file utils.c.

{
  Ppolynome ppp, p = POLYNOME_UNDEFINED;
  Pvecteur pv;
 
  for(ppp = *pp; ppp != NULL; ppp = ppp->succ) {
    entity first = entity_undefined,
           second = entity_undefined;
    pv = (ppp->monome)->term;
    for(; (pv != NULL) && (second == entity_undefined); pv = pv->succ) {
      second = first;
      first = (entity) pv->var;
    }
    if(pv != NULL)
      pips_internal_error("Vecteur should contains 2 var");
    else if(same_entity_p(first, var) || same_entity_p(second, var)) {
      if(POLYNOME_UNDEFINED_P(p)) {
        *pp = ppp->succ;
      }
      else
        p->succ = ppp->succ;
    }
    else
      p = ppp;
  }
}

References entity_undefined, Spolynome::monome, pips_internal_error, POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, same_entity_p(), Spolynome::succ, Svecteur::succ, term(), and Svecteur::var.

Here is the call graph for this function:

diff_lists()

list diff_lists	(	list	l1,
		list	l2
	)

========================================================================

Definition at line 868 of file utils.c.

{
  list l = NIL;
 
  if(l2 == NULL)
    return(l1);
 
  for( ; !ENDP(l1); POP(l1)) {
    chunk *c1 = CHUNK(CAR(l1));
    bool found = false;
    for(; (!ENDP(l2)) && (!found); POP(l2)) {
      chunk *c2 = CHUNK(CAR(l2));
      if(c1 == c2)
        found = true;
    }
    if(!found)
      l = gen_nconc(l, CONS(CHUNK, c1, NIL));
  }
  return(l);
}

References CAR, CHUNK, CONS, ENDP, gen_nconc(), NIL, and POP.

Here is the call graph for this function:

find_or_create_coeff()

entity find_or_create_coeff	(	string	prefix,
		int	n
	)

========================================================================

entity find_or_create_coeff(string prefix, int n): returns the entity that represent the coefficient numbered "n" and prefixed by "prefix". If it does not exist yet, we create it.

We create it, if it does not exist yet

Definition at line 238 of file utils.c.

{
 string num, name;
 entity new_coeff;
 
 num=int2a(n);
 name = strdup(concatenate(MAPPING_MODULE_NAME, MODULE_SEP_STRING,
                           prefix, num, (char *) NULL));
 new_coeff = gen_find_tabulated(name, entity_domain);
 
 /* We create it, if it does not exist yet */
 if(new_coeff == entity_undefined)
    new_coeff = make_coeff(prefix, n);
 
 free(num);
 return(new_coeff);
}

References concatenate(), entity_domain, entity_undefined, free(), gen_find_tabulated(), int2a(), make_coeff(), MAPPING_MODULE_NAME, MODULE_SEP_STRING, num, prefix, and strdup().

Referenced by apply_farkas(), put_source_ind(), and valuer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_graph_dataflows()

list get_graph_dataflows

(

graph

g

)

========================================================================

list get_graph_dataflows(graph g): returns the list of dataflows of the DFG graph "g". Each edge of "g" contains a list of dataflows, so we concatenate these lists into one.

Definition at line 765 of file utils.c.

{
  list l, su_l, g_dfs;
 
  g_dfs = NIL;
  for(l = graph_vertices(g); !ENDP(l); POP(l)) {
    for(su_l = vertex_successors(VERTEX(CAR(l))); !ENDP(su_l); POP(su_l)) {
      list dfs = gen_append(SUCC_DATAFLOWS(SUCCESSOR(CAR(su_l))), NIL);
      g_dfs = gen_nconc(g_dfs, dfs);
    }
  }
 
  return(g_dfs);
}

References CAR, ENDP, gen_append(), gen_nconc(), graph_vertices, NIL, POP, SUCC_DATAFLOWS, SUCCESSOR, VERTEX, and vertex_successors.

Referenced by prgm_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

get_stmt_index_coeff()

list get_stmt_index_coeff	(	int	stmt,
		hash_table	StoL
	)

========================================================================

Definition at line 792 of file utils.c.

{
  list proto_lambda, prec, pl;
 
  proto_lambda = gen_append((list) hash_get(StoL, (char *) stmt), NIL);
 
  prec = NIL;
  for(pl = proto_lambda; !ENDP(pl); POP(pl)) {
    entity e = ENTITY(CAR(pl));
    if(is_index_coeff_p(e))
      prec = pl;
    else
      if(prec == NIL)
        proto_lambda = CDR(proto_lambda);
      else
        CDR(prec) = CDR(pl);
  }
 
  return(proto_lambda);
}

References CAR, CDR, ENDP, ENTITY, gen_append(), hash_get(), is_index_coeff_p(), NIL, pl, and POP.

Referenced by broadcast_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_sort()

list insert_sort	(	list	l,
		bool (*)()	compare_obj
	)

========================================================================

list insert_sort(list l, bool (*compare_obj)()): returns the result of sorting the list "l" using the comparison function "compare_obj". This bool function should retuns true if its first argument has to be placed before its second argument in the sorted list, else FALSE.

This is a generic function that accepts any homogene list of newgen objects. The comparison function must be coded by the user, its prototype should be: bool my_compare_obj(chunk * obj1, chunk * obj2);

This function uses the insert sort algorithm which has a mean and worst case complexity of n^2.

Definition at line 110 of file utils.c.

{
  list al, aal, nl = NIL, nnl, nnl_q;
  chunk * ngo, * aux_ngo;
  bool not_inserted;
 
  for(al = l; al != NIL; al = CDR(al)) {
    ngo = CHUNK(CAR(al));
    not_inserted = true;
    nnl = NIL;
    nnl_q = nnl;
 
    for(aal = nl; (aal != NIL) && not_inserted ; aal = CDR(aal)) {
       aux_ngo = CHUNK(CAR(aal));
       if(compare_obj(ngo, aux_ngo)) {
          nnl = gen_nconc(gen_nconc(nnl, CONS(CHUNK, ngo, NIL)), aal);
          not_inserted = false;
       }
       else
          nnl = gen_nconc(nnl, CONS(CHUNK, aux_ngo, NIL));
    }
    if(not_inserted)
       nnl = gen_nconc(nnl, CONS(CHUNK, ngo, NIL));
 
    nl = nnl;
  }
 
  return(nl);
}

References CAR, CDR, CHUNK, CONS, gen_nconc(), and NIL.

Here is the call graph for this function:

is_broadcast_p()

bool is_broadcast_p

(

dataflow

df

)

========================================================================

bool is_broadcast_p(dataflow df): returns true if the dataflow "df" has a defined broadcast communication. Otherwise it returns FALSE.

Definition at line 1088 of file utils.c.

{
  communication com;
  predicate bp;
  Psysteme ps;
 
  com = dataflow_communication(df);
  if(com == communication_undefined)
    return(false);
 
  bp = communication_broadcast(com);
  if(bp == predicate_undefined)
    return(false);
 
  ps = (Psysteme) predicate_system(bp);
  if(ps == NULL)
    return(false);
  else
    return(true);
}

References communication_broadcast, communication_undefined, dataflow_communication, predicate_system, and predicate_undefined.

Referenced by broadcast_conditions(), and edge_weight().

Here is the caller graph for this function:

is_index_coeff_p()

bool is_index_coeff_p

(

entity

e

)

========================================================================

Definition at line 144 of file utils.c.

{
  if( (strncmp(entity_local_name(e), INDEX_COEFF, 1) == 0) ||
      (strncmp(entity_local_name(e), MU_COEFF, 1) == 0) )
    return(true);
  else
    return(false);
}

References entity_local_name(), INDEX_COEFF, and MU_COEFF.

Referenced by get_stmt_index_coeff(), partition_unknowns(), rm_non_x_var(), and sort_unknowns().

Here is the call graph for this function:

Here is the caller graph for this function:

is_reduction_p()

bool is_reduction_p

(

dataflow

df

)

========================================================================

bool is_reduction_p(dataflow df): returns true if the dataflow "df" has a defined reduction communication. Otherwise it returns FALSE.

Definition at line 1150 of file utils.c.

{
 communication com = dataflow_communication(df);
 predicate bp;
 Psysteme ps;
 
 if(com == communication_undefined)
    return(false);
 
 bp = communication_reduction(com);
 if(bp == predicate_undefined)
   return(false);
 
 ps = (Psysteme) predicate_system(bp);
 if(ps == NULL)
   return(false);
 else
   return(true);
}

References communication_reduction, communication_undefined, dataflow_communication, predicate_system, and predicate_undefined.

Referenced by edge_weight().

Here is the caller graph for this function:

is_shift_p()

bool is_shift_p

(

dataflow

df

)

========================================================================

bool is_shift_p(dataflow df): returns true if the dataflow "df" has a defined shift communication. Otherwise it returns FALSE.

Definition at line 1176 of file utils.c.

{
 communication com = dataflow_communication(df);
 predicate bp;
 Psysteme ps;
 
 if(com == communication_undefined)
    return(false);
 
 bp = communication_shift(com);
 if(bp == predicate_undefined)
   return(false);
 
 ps = (Psysteme) predicate_system(bp);
 if(ps == NULL)
   return(false);
 else
   return(true);
}

References communication_shift, communication_undefined, dataflow_communication, predicate_system, and predicate_undefined.

make_coeff()

entity make_coeff	(	string	prefix,
		int	n
	)

========================================================================

entity make_coeff(string prefix, int n): returns a new entity which will be used as a coefficient in a prototype of a placement function. All coefficients differ in their name which is something like: "MAPPING:prefix#" where # is the integer value of "n".

Definition at line 209 of file utils.c.

{
 string num, name;
 entity new_coeff;
 
 num=int2a(n);
 
 name = strdup(concatenate(MAPPING_MODULE_NAME, MODULE_SEP_STRING,
                           prefix, num, (char *) NULL));
 
 new_coeff = make_entity(name,
                         make_type(is_type_variable,
                                   make_variable(make_basic(is_basic_int, 4),
                                                 NIL)),
                         make_storage(is_storage_rom, UU),
                         make_value(is_value_unknown, UU));
 
 free(num);
 return(new_coeff);
}

References concatenate(), free(), int2a(), is_basic_int, is_storage_rom, is_type_variable, is_value_unknown, make_basic(), make_entity, make_storage(), make_type(), make_value(), make_variable(), MAPPING_MODULE_NAME, MODULE_SEP_STRING, NIL, num, prefix, strdup(), and UU.

Referenced by find_or_create_coeff(), initialize_mu_list(), and plc_make_proto().

Here is the call graph for this function:

Here is the caller graph for this function:

my_substitute_var_with_vec()

void my_substitute_var_with_vec	(	Psysteme	ps,
		entity	var,
		int	val,
		Pvecteur	vec
	)

===========================================================================

void my_substitute_var_with_vec(Psysteme ps, entity var, int val, Pvecteur vec): Substitutes in a system ("ps") a variable ("var"), factor of a positive value ("val"), by an expression ("vec").

This substitution is done on all assertions of the system (equalities and inequalities). For each assertion (represented by a vector Vold) we have:

 Vold = c*var + Vaux
 val*var = vec

Vnew represents the new assertion. With: p = gcd(c, val) >= 1, we have:

 Vnew = (c/p)*vec + (val/p)*Vaux = (c/p)*vec + (val/p)*(Vold - c*var)

Note: we have: Vold == 0 <=> (val/p)*Vold == 0 Vold > 0 <=> (val/p)*Vold > 0 ...

because "val" is positive.

If we want to substitute a NULL vector, we just erase "Var"

"val" must be positive.

Vnew = (c/p)*vec + (val/p)*Vaux = (c/p)*vec + (val/p)*(Vold - c*var)

Definition at line 1219 of file utils.c.

{
 Variable Var = (Variable) var;
 Pcontrainte assert;
 
 if(get_debug_level() > 8) {
fprintf(stderr, "\t\t\tAvant Sub: \n");
fprint_psysteme(stderr, ps);
fprintf(stderr, "\n");
 }
 
  /* If we want to substitute a NULL vector, we just erase "Var" */
  if(VECTEUR_NUL_P(vec)) {
    for(assert = ps->egalites; assert != NULL; assert = assert->succ) {
      Pvecteur v_old = assert->vecteur;
      vect_erase_var(&v_old, Var);
    }
    for(assert = ps->inegalites; assert != NULL; assert = assert->succ) {
      Pvecteur v_old = assert->vecteur;
      vect_erase_var(&v_old, Var);
    }
  }
 
  /* "val" must be positive. */
  if(val < 0) {
    val = 0-val;
    vect_chg_sgn(vec);
  }
 
  /* Vnew = (c/p)*vec + (val/p)*Vaux = (c/p)*vec + (val/p)*(Vold - c*var) */
  for(assert = ps->egalites; assert != NULL; assert = assert->succ) {
    Pvecteur v_old = assert->vecteur;
    int coeff = vect_coeff(Var, v_old);
    if(coeff != 0) {
      int p = pgcd(coeff, val);
 
      assert->vecteur = vect_cl2_ofl_ctrl(coeff/p, vec,
                                          val/p,
                                          vect_cl2_ofl_ctrl(1, v_old, -1,
                                                            vect_new(Var,
                                                                     coeff),
                                                            NO_OFL_CTRL),
                                          NO_OFL_CTRL);
    }
  }
  for(assert = ps->inegalites; assert != NULL; assert = assert->succ) {
    Pvecteur v_old = assert->vecteur;
    int coeff = vect_coeff(Var, v_old);
    if(coeff != 0) {
      int p = pgcd(coeff, val);
 
      assert->vecteur = vect_cl2_ofl_ctrl(coeff/p, vec,
                                          val/p,
                                          vect_cl2_ofl_ctrl(1, v_old, -1,
                                                            vect_new(Var,
                                                                     coeff),
                                                            NO_OFL_CTRL),
                                          NO_OFL_CTRL);
    }
  }
  vect_rm((Pvecteur) ps->base);
  ps->base = (Pbase) NULL;
  sc_creer_base(ps);
 
 if(get_debug_level() > 8) {
fprintf(stderr, "\t\t\tApres Sub: \n");
fprint_psysteme(stderr, ps);
fprintf(stderr, "\n");
 }
 
}

References assert, fprint_psysteme(), fprintf(), get_debug_level(), NO_OFL_CTRL, pgcd, sc_creer_base(), vect_chg_sgn(), vect_cl2_ofl_ctrl(), vect_coeff(), vect_erase_var(), vect_new(), vect_rm(), and VECTEUR_NUL_P.

Referenced by plc_elim_var_with_eg().

Here is the call graph for this function:

Here is the caller graph for this function:

new_elim_var_with_eg()

Psysteme new_elim_var_with_eg	(	Psysteme	ps,
		list *	init_l,
		list *	elim_l
	)

========================================================================

Psysteme new_elim_var_with_eg(Psysteme ps, list *init_l, list *elim_l): Computes the gaussian elimination of variables in the system "ps". The modifications are directly done on "ps".

However, we keep all the eliminated equations in "sc_elim", and return that system.

Initially, "init_l" gives the list of variables that can be eliminated, at the end, it only contains the variables that were not eliminated. We take the order of this list in our process of eliminating.

Initially, "elim_l" is empty, at the end it contains the variables that were eliminated.

During the computation, we modify *init_l, so we duplicate it. We use "el" not *elim_l, which should be empty at the beginning.

si eq etait en tete il faut l'enlever de la liste, sinon, eq a ete enleve dans la fonction contrainte_var_min_coeff().

Definition at line 338 of file utils.c.

{
  Psysteme sc_elim = sc_new();
 
  /* During the computation, we modify *init_l, so we duplicate it.
   * We use "el" not *elim_l, which should be  empty at the beginning.
   */
  list vl = gen_append(*init_l, NIL),
       el = NIL,         
       l;
  Pcontrainte eq, eg;
 
  for(l = vl; !ENDP(l); POP(l)) {
    Variable v = (Variable) ENTITY(CAR(l));
    Value coeff;
 
    if ((eq = contrainte_var_min_coeff(ps->egalites,v, &coeff, true))
        != NULL) {
 
 if(get_debug_level() > 7) {
fprintf(stderr, "System is :");
fprint_psysteme(stderr, ps);
fprintf(stderr, "\t\tElim var %s in equation:", entity_local_name((entity) v));
pu_vect_fprint(stderr, eq->vecteur);
fprintf(stderr, "\n");
 }
 
      if(!egalite_normalize(eq))
        pips_internal_error("Egalite bizarre");
 
      sc_nbre_egalites(ps)--;
      if (eq == (ps->egalites)) ps->egalites = eq->succ;
      /* si eq etait en tete il faut l'enlever de la liste, sinon, eq a
         ete enleve dans la fonction contrainte_var_min_coeff(). */
 
      for(eg = ps->egalites; eg != NULL; eg = eg->succ)
        (void) contrainte_subst_ofl_ctrl(v, eq, eg, true, NO_OFL_CTRL);
      for(eg = ps->inegalites; eg != NULL; eg = eg->succ)
        (void) contrainte_subst_ofl_ctrl(v, eq, eg, false, NO_OFL_CTRL);
 
      for(eg = sc_elim->egalites; eg != NULL; eg = eg->succ)
        (void) contrainte_subst_ofl_ctrl(v, eq, eg, true, NO_OFL_CTRL);
      for(eg = sc_elim->inegalites; eg != NULL; eg = eg->succ)
        (void) contrainte_subst_ofl_ctrl(v, eq, eg, false, NO_OFL_CTRL);
 
      sc_add_egalite(sc_elim, eq);
      gen_remove(init_l, (chunk *) v);
      el = CONS(ENTITY, (entity) v, el);
    }
  }
 
  *elim_l = el;
  sc_elim->base = NULL;
  sc_creer_base(sc_elim);
 
 if(get_debug_level() > 6) {
fprintf(stderr, "[new_elim_var_with_eg] Results:\n");
fprintf(stderr, "Elim sys:\n");
fprint_entity_list(stderr, el);
fprint_psysteme(stderr, sc_elim);
fprintf(stderr, "Remnants sys:\n");
fprint_entity_list(stderr, *init_l);
fprint_psysteme(stderr, ps);
fprintf(stderr, "\n");
 }
 
  return(sc_elim);
}

References Ssysteme::base, CAR, CONS, contrainte_subst_ofl_ctrl(), contrainte_var_min_coeff(), egalite_normalize(), Ssysteme::egalites, ENDP, ENTITY, entity_local_name(), eq, fprint_entity_list(), fprint_psysteme(), fprintf(), gen_append(), gen_remove(), get_debug_level(), Ssysteme::inegalites, NIL, NO_OFL_CTRL, pips_internal_error, POP, pu_vect_fprint(), sc_add_egalite(), sc_creer_base(), sc_new(), Scontrainte::succ, and Scontrainte::vecteur.

Here is the call graph for this function:

nullify_factors()

Psysteme nullify_factors	(	Ppolynome *	pp,
		list	var_l,
		bool	with_remnants
	)

========================================================================

For each variable, we nullify its factor in the polynome.

We get the current variable.

We get its factor in the polynome.

We add a new equality in the system.

We delete the occurences of this variable in the polynome.

The remnants are zero out and are added as one equation.

Definition at line 1026 of file utils.c.

{
  Ppolynome aux_pp = *pp;
  Psysteme new_ps = sc_new();
  list l;
 
  if(get_debug_level() > 4) {
    fprintf(stderr, "[nullify_factors] polynome is :");
    polynome_fprint(stderr, aux_pp, pu_variable_name, pu_is_inferior_var);
    fprintf(stderr, "\n");
  }
 
  if(!POLYNOME_NUL_P(aux_pp)) {
 
    /* For each variable, we nullify its factor in the polynome. */
    for(l = var_l; l != NIL; l = CDR(l)) {
      /* We get the current variable. */
      entity var = ENTITY(CAR(l));
 
      /* We get its factor in the polynome. */
      Pvecteur pv_fac = prototype_factorize(aux_pp, (Variable) var);
 
      if(get_debug_level() > 5) {
        fprintf(stderr, "[nullify_factors] factor is :");
        pu_vect_fprint(stderr, pv_fac);
        fprintf(stderr, "\n");
      }
 
      if(!VECTEUR_NUL_P(pv_fac)) {
        /* We add a new equality in the system. */
        sc_add_egalite(new_ps, contrainte_make(pv_fac));
 
        /* We delete the occurences of this variable in the polynome. */
        aux_pp = prototype_var_subst(aux_pp, (Variable) var, POLYNOME_NUL);
      }
    }
 
    if( (with_remnants) && (!POLYNOME_NUL_P(aux_pp)) )
      /* The remnants are zero out and are added as one equation. */
      sc_add_egalite(new_ps, polynome_to_contrainte(aux_pp));
 
    if(get_debug_level() > 4) {
      fprintf(stderr, "[nullify_factors] final new sys :");
      fprint_psysteme(stderr, new_ps);
      fprintf(stderr, "\n");
    }
 
    sc_creer_base(new_ps);
    sc_normalize(new_ps);
    *pp = aux_pp;
  }
  return(new_ps);
}

References CAR, CDR, contrainte_make(), ENTITY, fprint_psysteme(), fprintf(), get_debug_level(), NIL, polynome_fprint(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_to_contrainte(), prototype_factorize(), prototype_var_subst(), pu_is_inferior_var(), pu_variable_name(), pu_vect_fprint(), sc_add_egalite(), sc_creer_base(), sc_new(), sc_normalize(), and VECTEUR_NUL_P.

Referenced by cutting_conditions(), and valuer().

Here is the call graph for this function:

Here is the caller graph for this function:

old_prototype_factorize()

Pvecteur old_prototype_factorize	(	Ppolynome	pp,
		Variable	var
	)

========================================================================

Definition at line 1300 of file utils.c.

{
  Pvecteur pv = NULL;
 
  if(POLYNOME_NUL_P(pp))
    pv = VECTEUR_NUL;
  else if(var == TCST)
    pv = vect_new(TCST, (int) polynome_TCST(pp));
  else {
    Ppolynome ppp;
 
    for(ppp = pp; ppp != NULL; ppp = ppp->succ) {
      Variable newvar = VARIABLE_UNDEFINED;
      int newval;
      Pvecteur vec, newpv;
      entity first = entity_undefined, second = entity_undefined;
      bool factor_found = true;
 
      vec = (ppp->monome)->term;
      for(; (vec != NULL) && (second == entity_undefined); vec = vec->succ) {
        second = first;
        first = (entity) vec->var;
      }
      if(vec != NULL)
        pips_internal_error("Vecteur should contains 2 var");
      else if(same_entity_p(first,  (entity) var))
        if(second == entity_undefined)
          newvar = TCST;
        else
          newvar = (Variable) second;
      else if(same_entity_p(second, (entity) var))
        newvar = (Variable) first;
      else
        factor_found = false;
 
      if(factor_found) {
        newval = (int) (ppp->monome)->coeff;
        newpv = vect_new(newvar, newval);
        newpv->succ = pv;
        pv = newpv;
      }
    }
  }
 
  return(pv);
}

References entity_undefined, int, Spolynome::monome, pips_internal_error, POLYNOME_NUL_P, polynome_TCST(), same_entity_p(), Spolynome::succ, Svecteur::succ, TCST, term(), Svecteur::var, VARIABLE_UNDEFINED, vect_new(), and VECTEUR_NUL.

Here is the call graph for this function:

plc_elim_var_with_eg()

Psysteme plc_elim_var_with_eg	(	Psysteme	ps,
		list *	init_l,
		list *	elim_l
	)

========================================================================

Psysteme plc_elim_var_with_eg(Psysteme ps, list *init_l, list *elim_l): Computes the gaussian elimination of variables in the system "ps". The modifications are directly done on "ps".

However, we keep all the eliminated equations in "sc_elim", and return that system.

Initially, "init_l" gives the list of variables that can be eliminated, at the end, it only contains the variables that were not eliminated. We take the order of this list in our process of eliminating.

Initially, "elim_l" is empty, at the end it contains the variables that were eliminated.

We use "vl" during the computation, not *init_l

We use "el" during the computation, not *elim_l

This elimination works only on equalities. While there remains equalities, we can eliminate variables.

We look, in vl (i.e. init_l), for a variable that we can eliminate in ve, i.e. with a coefficient equal to 1 or -1.

If we get such a variable, we eliminate it.

First, we remove it from "vl".

Then, we add it to "el".

We keep a copy of the initial vector.

We compute the expression (pv_elim) by which we are going to substitute our variable (var):

We have: var = pv_elim

The equality is: V = 0, with: V = val*var + Vaux, and: val in {-1,1}

So, we have: pv_elim = -val*Vaux, with: Vaux = V - val*var

So: pv_elim = -val(V - val*var) i.e.: pv_elim = -val+V + (val^2)*var but: val in {-1,1}, so: val^2 = 1

so: pv_elim = -val*V + var

We substitute var by its value (pv_elim) in "ps".

We substitute var by its value (pv_elim) in "sc_elim".

The initial equality is added to "sc_elim".

We reinitialize the list of equalities.

Else, we try on the next equality.

Definition at line 426 of file utils.c.

{
 bool var_not_found;
 Psysteme sc_elim = sc_new();
 Pcontrainte eqs;
 Pvecteur ve, pv_elim;
 entity crt_var = entity_undefined;
 int crt_val = 0;
 list vl = *init_l,     /* We use "vl" during the computation, not *init_l */
      el = NIL,         /* We use "el" during the computation, not *elim_l */
      l;
 
 /* This elimination works only on equalities. While there remains equalities,
  * we can eliminate variables.
  */
 eqs = ps->egalites;
 while(eqs != NULL)
   {
    ve = eqs->vecteur;
 
 if(get_debug_level() > 8) {
fprintf(stderr, "System is :");
fprint_psysteme(stderr, ps);
fprintf(stderr, "\t\tConsidered Vect :");
pu_vect_fprint(stderr, ve);
fprintf(stderr, "\n");
 }
 
    /* We look, in vl (i.e. init_l), for a variable that we can eliminate in
     * ve, i.e. with a coefficient equal to 1 or -1.
     */
    var_not_found = true;
    for(l = vl ; (l != NIL) && var_not_found; l = CDR(l)) {
      crt_var = ENTITY(CAR(l));
      crt_val = (int) vect_coeff((Variable) crt_var, ve);
      if((crt_val == 1) || (crt_val == -1))
        var_not_found = false;
    }
 
    /* If we get such a variable, we eliminate it. */
    if(! var_not_found)
      {
       Pvecteur init_vec;
 
       /* First, we remove it from "vl". */
       gen_remove(&vl, (chunk *) crt_var);
 
       /* Then, we add it to "el". */
       el = CONS(ENTITY, crt_var, el);
 
       /* We keep a copy of the initial vector. */
       init_vec = vect_dup(eqs->vecteur);
 
       /* We compute the expression (pv_elim) by which we are going to
        * substitute our variable (var):
        *
        * We have: var = pv_elim
        *
        * The equality is: V = 0, with: V = val*var + Vaux, and: val in {-1,1}
        *
        * So, we have: pv_elim = -val*Vaux, with: Vaux = V - val*var
        *
        * So: pv_elim = -val(V - val*var)
        * i.e.: pv_elim = -val+V + (val^2)*var
        * but: val in {-1,1}, so: val^2 = 1
        *
        * so: pv_elim = -val*V + var
        *
        */
       pv_elim = vect_cl2_ofl_ctrl((crt_val)*(-1), eqs->vecteur,
                                   1, vect_new((Variable) crt_var, 1),
                                   NO_OFL_CTRL);
 
 if(get_debug_level() > 7) {
fprintf(stderr, "\t\tElim with %s = ", entity_local_name(crt_var));
pu_vect_fprint(stderr, pv_elim);
fprintf(stderr, "\n");
 }
 
       /* We substitute var by its value (pv_elim) in "ps". */
       my_substitute_var_with_vec(ps, crt_var, 1, vect_dup(pv_elim));
 
       /* We substitute var by its value (pv_elim) in "sc_elim". */
       my_substitute_var_with_vec(sc_elim, crt_var, 1, vect_dup(pv_elim));
 
       ps = sc_normalize(ps);
       vect_rm(pv_elim);
 
 if(get_debug_level() > 7) {
fprintf(stderr, "New System is :");
fprint_psysteme(stderr, ps);
 }
 
       /* The initial equality is added to "sc_elim". */
       sc_add_egalite(sc_elim, contrainte_make(init_vec));
 
 
       /* We reinitialize the list of equalities. */
       eqs = ps->egalites;
      }
    /* Else, we try on the next equality. */
    else
       eqs = eqs->succ;
   }
 *init_l = vl;
 *elim_l = el;
 sc_elim->base = NULL;
 sc_creer_base(sc_elim);
 
 if(get_debug_level() > 6) {
fprintf(stderr, "[plc_elim_var_with_eg] Results:\n");
fprintf(stderr, "Elim sys:\n");
fprint_entity_list(stderr, el);
fprint_psysteme(stderr, sc_elim);
fprintf(stderr, "Remnants sys:\n");
fprint_entity_list(stderr, vl);
fprint_psysteme(stderr, ps);
fprintf(stderr, "\n");
 }
 
 return(sc_elim);
}

References Ssysteme::base, CAR, CDR, CONS, contrainte_make(), ENTITY, entity_local_name(), entity_undefined, fprint_entity_list(), fprint_psysteme(), fprintf(), gen_remove(), get_debug_level(), int, my_substitute_var_with_vec(), NIL, NO_OFL_CTRL, pu_vect_fprint(), sc_add_egalite(), sc_creer_base(), sc_new(), sc_normalize(), Scontrainte::succ, vect_cl2_ofl_ctrl(), vect_coeff(), vect_dup(), vect_new(), vect_rm(), and Scontrainte::vecteur.

Here is the call graph for this function:

put_source_ind()

list put_source_ind

(

list

le

)

========================================================================

list put_source_ind(list le): returns a list of expressions computed from the list given in argument ("le").

We want to associate a variable (var) to each expression (exp) in order to have some kind of equality : 0 = exp - var which means in fact : var = exp

The name of the variables are not important, however, we need a different variable for each expression.

Note: the variables are entities.

This counter makes sure that each new variable is different for the preceding one.

The resulting list is initialized to NIL.

For each expression we compute the new expression.

We get a new variable (an entity).

We make the new expression : exp - var.

This expression is added to the new list. The order is kept.

Definition at line 596 of file utils.c.

{
 int count = 1; /* This counter makes sure that each new variable is different
                 * for the preceding one.
                 */
 expression texp, new_texp;
 entity en;
 list l,
      new_le = NIL;     /* The resulting list is initialized to NIL. */
 
 /* For each expression we compute the new expression. */
 for(l = le; l != NIL; l = CDR(l), count++)
   {
    normalized nor;
 
    /* We get a new variable (an entity). */
    en = find_or_create_coeff(INDEX_VARIA, count);
 
    texp = EXPRESSION(CAR(l));
    NORMALIZE_EXPRESSION(texp);
    nor = expression_normalized(texp);
 
    if(normalized_tag(nor) == is_normalized_linear) {
      Pvecteur pv = normalized_linear(nor);
      pv = vect_cl_ofl_ctrl(pv, -1, vect_new((Variable) en, 1), NO_OFL_CTRL);
      new_texp = make_vecteur_expression(pv);
    }
    else {
      /* We make the new expression : exp - var. */
      new_texp = make_op_exp(MINUS_OPERATOR_NAME,
                             texp, make_entity_expression(en, NIL));
    }
 
    /* This expression is added to the new list. The order is kept. */
    new_le = gen_nconc(new_le, CONS(EXPRESSION, new_texp, NIL));
   }
 return(new_le);
}

References CAR, CDR, CONS, count, EXPRESSION, expression_normalized, find_or_create_coeff(), gen_nconc(), INDEX_VARIA, is_normalized_linear, make_entity_expression(), make_op_exp(), make_vecteur_expression(), MINUS_OPERATOR_NAME, NIL, NO_OFL_CTRL, NORMALIZE_EXPRESSION, normalized_linear, normalized_tag, vect_cl_ofl_ctrl(), and vect_new().

Referenced by edge_weight().

Here is the call graph for this function:

Here is the caller graph for this function:

rm_non_x_var()

list rm_non_x_var

(

list

l

)

========================================================================

Definition at line 260 of file utils.c.

{
  list prec, aux_l;
 
if(get_debug_level() > 6) {
fprintf(stderr, "\n[rm_non_x_var] Bases de depart :\n");
fprint_entity_list(stderr, l);
fprintf(stderr, "\n");
}
 
  prec = NIL;
  for(aux_l = l; !ENDP(aux_l); POP(aux_l)) {
    entity crt_var = ENTITY(CAR(aux_l));
    if(!is_index_coeff_p(crt_var)) {
      if(prec == NIL)
        l = CDR(l);
      else
        CDR(prec) = CDR(aux_l);
    }
    else
      prec = aux_l;
  }
 
if(get_debug_level() > 6) {
fprintf(stderr, "\n[rm_non_x_var] Base d'arrivee :\n");
fprint_entity_list(stderr, l);
fprintf(stderr, "\n");
}
 
  return(l);
}

References CAR, CDR, ENDP, ENTITY, fprint_entity_list(), fprintf(), get_debug_level(), is_index_coeff_p(), NIL, and POP.

Here is the call graph for this function:

unify_lists()

list unify_lists	(	list	l1,
		list	l2
	)

========================================================================

Definition at line 295 of file utils.c.

{
  list l;
  
  if(l1 == NULL)
    l = gen_append(l2, NIL);
  else {
    l = gen_append(l1, NIL);
 
    for(; !ENDP(l2); POP(l2)) {
      chunk * c2 = CHUNK(CAR(l2));
      bool found = false;
      for(; (!ENDP(l1)) && (!found); POP(l1)) {
        chunk *c1 = CHUNK(CAR(l1));
        if(c1 == c2)
          found = true;
      }
      if(! found)
        gen_nconc(l, CONS(CHUNK, c2, NIL));
    }
  }
 
  return(l);
}

References CAR, CHUNK, CONS, ENDP, gen_append(), gen_nconc(), NIL, and POP.

Here is the call graph for this function:

vecteurs_libres_p()

bool vecteurs_libres_p	(	Psysteme	sys,
		Pbase	v_base,
		Pbase	c_base
	)

========================================================================

add 1, because of the TCST

Definition at line 903 of file utils.c.

{
  int n, m1, m2, r;
  Value det_p, det_q;
  matrice A, B, P, H, Q;
 
  n = sys->nb_eq;
  m1 = base_dimension(v_base);
 
  if(m1 < n)
    return(false);
 
  m2 = base_dimension(c_base) + 1; /* add 1, because of the TCST */
  A = matrice_new(n,m1);
  B = matrice_new(n,m2);
 
  contraintes_with_sym_cst_to_matrices(sys->egalites,v_base,c_base,
                                       A,B,n,m1,m2);
 
  P = matrice_new(n,n);
  Q = matrice_new(m1,m1);
  H = matrice_new(n,m1);
  matrice_hermite(A, n, m1, P, H, Q, &det_p, &det_q);
 
  r = matrice_hermite_rank(H, n, m1);
 
  matrice_free(A);
  matrice_free(B);
  matrice_free(P);
  matrice_free(Q);
  matrice_free(H);
 
  return(r == n);
}

References A, B, base_dimension, contraintes_with_sym_cst_to_matrices(), matrice_free, matrice_hermite(), matrice_hermite_rank(), matrice_new, and Q.

Referenced by base_complete(), broadcast_conditions(), completer_base(), completer_n_base(), mapping_on_broadcast(), prepare_reindexing(), and stmt_bdt_directions().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

prgm_parameter_l

list prgm_parameter_l

extern

lint

Name : utils.c Package : prgm_mapping Author : Alexis Platonoff Date : 23 september 1993

Historic :

• 6 dec 93, some new functions, AP
• 14 nov 94, remove find_implicit_equation(), put in paf-util, AP

Documents:

Comments : This file contains useful functions used for the computation of prgm_mapping. Ansi includes
Newgen includes
C3 includes
Pips includes
Useful constants Macro functions
Global variables

lint

Definition at line 115 of file prgm_mapping.c.

Referenced by apply_farkas(), cutting_conditions(), partial_broadcast_coefficients(), plc_make_proto(), prgm_mapping(), and valuer().

vcid_prgm_mapping_utils

char vcid_prgm_mapping_utils[] = "$Id: utils.c 23065 2016-03-02 09:05:50Z coelho $"

Definition at line 29 of file utils.c.