reindexing.c File Reference

#include <stdio.h>
#include <stdlib.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 "sparse_sc.h"
#include "ri.h"
#include "constants.h"
#include "control.h"
#include "ri-util.h"
#include "misc.h"
#include "complexity_ri.h"
#include "database.h"
#include "graph.h"
#include "dg.h"
#include "paf_ri.h"
#include "parser_private.h"
#include "property.h"
#include "reduction.h"
#include "text.h"
#include "text-util.h"
#include "tiling.h"
#include "pipsdbm.h"
#include "resources.h"
#include "static_controlize.h"
#include "paf-util.h"
#include "pips.h"
#include "array_dfg.h"
#include "prgm_mapping.h"
#include "conversion.h"
#include "scheduling.h"
#include "reindexing.h"

Include dependency graph for reindexing.c:

Go to the source code of this file.

Macros
#define	STRING_BDT   "t"
	Name : reindexing.c Package : reindexing Author : Alexis Platonoff & Antoine Cloue Date : april 1994 Historic : More...
#define	STRING_PLC   "p"
#define	STRING_TAU   "q"
#define	STRING_FLAG   "flag"
#define	MAKE_STATEMENT(ins)   (make_statement(entity_empty_label(),STATEMENT_NUMBER_UNDEFINED,STATEMENT_ORDERING_UNDEFINED,string_undefined,ins))
#define	INTEGER_DEC   0
	We define a set of constant in order to a more generic function for the insert of the declarations of the new created variables. More...
#define	REAL_DEC   1
#define	COMPLEX_DEC   2
#define	LOGICAL_DEC   3
#define	DOUBLE_DEC   4
#define	CHARACTER_DEC   5
#define	INTEGER_DECL   " INTEGER"
#define	REAL_DECL   " REAL"
#define	COMPLEX_DECL   " COMPLEX"
#define	LOGICAL_DECL   " LOGICAL"
#define	DOUBLE_DECL   " DOUBLE"
#define	CHARACTER_DECL   " CHARACTER"
#define	COLON   ":"
#define	NEWLINE   "\n *"
#define	ENDLINE   "\n"
#define	LINE_LENGHT   68
#define	MARGIN_LENGHT   7
#define	IS_MIN   0
#define	IS_MAX   1
#define	DOUBLE_PRECISION_SIZE   8

Typedefs
typedef dfg_vertex_label	vertex_label
	Local defines. More...
typedef dfg_arc_label	arc_label

Functions
entity	get_time_ent (int st, char *typ, int count)
	================================================================== More...
void	build_contraction_matrices (int s, Psysteme ps, Pmatrix mH, int *c, Pmatrix *mQ, Pmatrix *mQ_inv, Pmatrix *mC, list *ln, list *lom, Pbase indx, Pbase cnst)
	======================================================================== More...
Psyslist	build_list_of_min (Psyslist lsys, list lnew, Psysteme ps)
	======================================================================= More...
list	dataflows_on_reference (list cls, reference crhs, predicate pred, list *lm)
	======================================================================= More...
instruction	build_local_time_test (entity t, list l)
	====================================================================== More...
expression	build_global_time_test_with_exp (entity tg, expression exp)
	====================================================================== More...
instruction	build_flag_assign (entity f, bool val)
	====================================================================== More...
instruction	build_flag_test (entity f, entity t)
	====================================================================== More...
instruction	make_init_time (entity en, expression ex)
	====================================================================== More...
instruction	make_increment_instruction (entity t, int i)
	===================================================================== More...
int	get_number_of_ins (entity e)
	====================================================================== More...
bool	reindexing (char *mod_name)
	====================================================================== More...

Variables
static int	tc
	Internal variables More...
hash_table	h_node
hash_table	delay_table
	Name : delay.c Package : reindexing Author : Alexis Platonoff Date : March 1995 Historic : More...
hash_table	ht_ab
list	lparams
	Array bounds. More...

Macro Definition Documentation

CHARACTER_DEC

#define CHARACTER_DEC   5

Definition at line 125 of file reindexing.c.

CHARACTER_DECL

#define CHARACTER_DECL   " CHARACTER"

Definition at line 132 of file reindexing.c.

COLON

#define COLON   ":"

Definition at line 133 of file reindexing.c.

COMPLEX_DEC

#define COMPLEX_DEC   2

Definition at line 122 of file reindexing.c.

COMPLEX_DECL

#define COMPLEX_DECL   " COMPLEX"

Definition at line 129 of file reindexing.c.

DOUBLE_DEC

#define DOUBLE_DEC   4

Definition at line 124 of file reindexing.c.

DOUBLE_DECL

#define DOUBLE_DECL   " DOUBLE"

Definition at line 131 of file reindexing.c.

DOUBLE_PRECISION_SIZE

#define DOUBLE_PRECISION_SIZE   8

Definition at line 143 of file reindexing.c.

ENDLINE

#define ENDLINE   "\n"

Definition at line 135 of file reindexing.c.

INTEGER_DEC

#define INTEGER_DEC   0

We define a set of constant in order to a more generic function for the insert of the declarations of the new created variables.

Definition at line 120 of file reindexing.c.

INTEGER_DECL

#define INTEGER_DECL   " INTEGER"

Definition at line 127 of file reindexing.c.

IS_MAX

#define IS_MAX   1

Definition at line 140 of file reindexing.c.

IS_MIN

#define IS_MIN   0

Definition at line 139 of file reindexing.c.

LINE_LENGHT

#define LINE_LENGHT   68

Definition at line 136 of file reindexing.c.

LOGICAL_DEC

#define LOGICAL_DEC   3

Definition at line 123 of file reindexing.c.

LOGICAL_DECL

#define LOGICAL_DECL   " LOGICAL"

Definition at line 130 of file reindexing.c.

MAKE_STATEMENT

#define MAKE_STATEMENT

(

ins

)

(make_statement(entity_empty_label(),STATEMENT_NUMBER_UNDEFINED,STATEMENT_ORDERING_UNDEFINED,string_undefined,ins))

Definition at line 102 of file reindexing.c.

MARGIN_LENGHT

#define MARGIN_LENGHT   7

Definition at line 137 of file reindexing.c.

NEWLINE

#define NEWLINE   "\n *"

Definition at line 134 of file reindexing.c.

REAL_DEC

#define REAL_DEC   1

Definition at line 121 of file reindexing.c.

REAL_DECL

#define REAL_DECL   " REAL"

Definition at line 128 of file reindexing.c.

STRING_BDT

#define STRING_BDT   "t"

Name : reindexing.c Package : reindexing Author : Alexis Platonoff & Antoine Cloue Date : april 1994 Historic :

• 19 jan 95 : remove my_make_rational_exp() and my_vect_var_subst(), AP
• 20 apr 95 : modification of get_time_ent(), AP
• 21 apr 95 : remove the functions dealing with "cell" in cell.c, AP

Documents: SOON Comments : This file contains the functions for the transformation of a program to a single assignment form. The main function is reindexing(). Ansi includes
Newgen includes
C3 includes
Pips includes
Macro functions

Definition at line 97 of file reindexing.c.

STRING_FLAG

#define STRING_FLAG   "flag"

Definition at line 100 of file reindexing.c.

STRING_PLC

#define STRING_PLC   "p"

Definition at line 98 of file reindexing.c.

STRING_TAU

#define STRING_TAU   "q"

Definition at line 99 of file reindexing.c.

Typedef Documentation

arc_label

typedef dfg_arc_label arc_label

Definition at line 115 of file reindexing.c.

vertex_label

typedef dfg_vertex_label vertex_label

Local defines.

Definition at line 114 of file reindexing.c.

Function Documentation

build_contraction_matrices()

void build_contraction_matrices	(	int	s,
		Psysteme	ps,
		Pmatrix	mH,
		int *	c,
		Pmatrix *	mQ,
		Pmatrix *	mQ_inv,
		Pmatrix *	mC,
		list *	ln,
		list *	lom,
		Pbase	indx,
		Pbase	cnst
	)

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

void build_contraction_matrices(mH, mQ, mQ_inv, mC, l)

From the matrix of Hermite mH, build the matrix mQ containing the periods of the different schedule dimension.

AC 94/03/31

build the matrix mC

Definition at line 197 of file reindexing.c.

{
  int         i, le = ps->nb_eq;
  Value ppc = VALUE_ONE;
  entity      ent;
  Psysteme    sc = sc_new();
  Pcontrainte cont;
 
  *ln = NIL;
  *lom = NIL;
  matrix_identity(*mQ, 0);
  matrix_identity(*mQ_inv, 0);
  
  if (get_debug_level() > 5)
    fprintf(stderr,"\nBuild_contraction matrice :");
 
  for (i = 1; i <= le; i++)
    ppc = ppcm(ppc, value_abs(MATRIX_ELEM(mH, i, i)));
 
  for (i = 1; i <= MATRIX_NB_LINES(*mQ); i++) {
    if (i <= le) {
        Value p = value_div(ppc,MATRIX_ELEM(mH, i, i)), x;
        MATRIX_ELEM(*mQ,i,i) = value_abs(p);
        ent = get_time_ent(s, STRING_TAU, (*c));
        (*c)++;
        ADD_ELEMENT_TO_LIST(*ln, ENTITY, ent);
 
        x = value_abs(MATRIX_ELEM(mH,i,i));
        ADD_ELEMENT_TO_LIST(*lom, INT, VALUE_TO_INT(x));
    }
    else 
        value_product(MATRIX_ELEM(*mQ,i,i), ppc);
  }
  
  MATRIX_DENOMINATOR(*mQ) = ppc;
 
  sc = matrix_to_system(*mQ, indx);
 
  cont = sc->egalites;
 
  while (ps->egalites != NULL) {
    cont->vecteur = vect_substract(cont->vecteur, (ps->egalites)->vecteur);
    cont = cont->succ;
    ps->egalites = (ps->egalites)->succ;
    ps->nb_eq--;
  }
 
  /* build the matrix mC */
  matrix_nulle(*mC);
 
  my_constraints_with_sym_cst_to_matrices(sc->egalites, indx, cnst, *mQ, *mC);
 
  MATRIX_DENOMINATOR(*mQ) = ppc;
  MATRIX_DENOMINATOR(*mC) = ppc;
 
  matrix_general_inversion(*mQ, *mQ_inv);
 
  if (get_debug_level() > 5)
    fprintf(stderr,"\nBuild_contraction_matrice fin\n");
}

References ADD_ELEMENT_TO_LIST, Ssysteme::egalites, ENTITY, fprintf(), get_debug_level(), get_time_ent(), INT, MATRIX_DENOMINATOR, MATRIX_ELEM, matrix_general_inversion(), matrix_identity(), MATRIX_NB_LINES, matrix_nulle(), matrix_to_system(), my_constraints_with_sym_cst_to_matrices(), Ssysteme::nb_eq, NIL, ppcm(), sc_new(), STRING_TAU, Scontrainte::succ, value_abs, value_div, VALUE_ONE, value_product, VALUE_TO_INT, vect_substract(), Scontrainte::vecteur, and x.

Referenced by prepare_reindexing().

Here is the call graph for this function:

Here is the caller graph for this function:

build_flag_assign()

instruction build_flag_assign	(	entity	f,
		bool	val
	)

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

instruction build_flag_assign(f, val) :

build the instruction: flag = val.

AC 94/06/14

Definition at line 531 of file reindexing.c.

{
  call     ca;
  list     lexp;
  expression e;
 
  if(val)
    e = int_to_expression(1);
  else
    e = int_to_expression(0);
 
  lexp = CONS(EXPRESSION, make_entity_expression(f, NIL), NIL);
  ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, e);
  ca = make_call(entity_intrinsic(ASSIGN_OPERATOR_NAME), lexp);
  
  return(make_instruction(is_instruction_call, ca));
}

References ADD_ELEMENT_TO_LIST, ASSIGN_OPERATOR_NAME, CONS, entity_intrinsic(), EXPRESSION, f(), int_to_expression(), is_instruction_call, lexp, make_call(), make_entity_expression(), make_instruction(), and NIL.

Referenced by re_do_it().

Here is the call graph for this function:

Here is the caller graph for this function:

build_flag_test()

instruction build_flag_test	(	entity	f,
		entity	t
	)

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

instruction build_flag_test(f, t)

Builds the instruction: IF flag == 1 THEN t = t + 1 ENDIF

AC 94/06/14

Definition at line 561 of file reindexing.c.

{
 call         ca;
 list         lexp;
 instruction  ins;
 statement    stat;
 expression   exp;
 
 ins = make_increment_instruction(t, 1);
 stat = MAKE_STATEMENT(ins);
 
 lexp = CONS(EXPRESSION, make_entity_expression(f, NIL), NIL);
 ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, int_to_expression(1));
 ca = make_call(entity_intrinsic(EQUAL_OPERATOR_NAME), lexp);
 exp = make_expression(make_syntax(is_syntax_call, ca), normalized_undefined);
 
 return(make_instruction(is_instruction_test, 
                         make_test(exp, stat, make_empty_statement())));
}

References ADD_ELEMENT_TO_LIST, CONS, entity_intrinsic(), EQUAL_OPERATOR_NAME, exp, EXPRESSION, f(), int_to_expression(), is_instruction_test, is_syntax_call, lexp, make_call(), make_empty_statement, make_entity_expression(), make_expression(), make_increment_instruction(), make_instruction(), MAKE_STATEMENT, make_syntax(), make_test(), NIL, and normalized_undefined.

Referenced by re_do_it().

Here is the call graph for this function:

Here is the caller graph for this function:

build_global_time_test_with_exp()

expression build_global_time_test_with_exp	(	entity	tg,
		expression	exp
	)

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

expression build_global_time_test_with_exp(tg, exp)

Builds the expression: tg == exp

AC 94/06/15

Definition at line 509 of file reindexing.c.

{
  list        lexp;
  call        ca;
 
  lexp = CONS(EXPRESSION, make_entity_expression(tg, NIL), NIL);
  ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, exp);
  ca = make_call(entity_intrinsic(EQUAL_OPERATOR_NAME), lexp);
  
  return(make_expression(make_syntax(is_syntax_call, ca),
                         normalized_undefined));
}

References ADD_ELEMENT_TO_LIST, CONS, entity_intrinsic(), EQUAL_OPERATOR_NAME, exp, EXPRESSION, is_syntax_call, lexp, make_call(), make_entity_expression(), make_expression(), make_syntax(), NIL, and normalized_undefined.

Referenced by build_first_comb(), and build_third_comb().

Here is the call graph for this function:

Here is the caller graph for this function:

build_list_of_min()

Psyslist build_list_of_min	(	Psyslist	lsys,
		list	lnew,
		Psysteme	ps
	)

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

build_list_of_min()

From the list of psystem "lsys", take each inequality (that is an expression of a possible lower bound), and create as many systems as necessary to raise the undetermination on the domain. This is done until the counter is equal to 0 meaning that all "t" variables have been treated.

AC 94/05/05

get the system corresponding to the current variable

there is already an unique minimum

add inequalities on the max

put the value of the min in the equality

search on the next t variable

for each possible minimum build new system

include new value of the min in the system

put the inequality on the current minimum

add inequalities on the max

put the minimum value that is the l in "t = omega*to + l"

in the equality part of the system. Problem if val != 1

get the next dimension

Definition at line 276 of file reindexing.c.

{
  Psysteme     sc_aux, ps_aux2;
  Pcontrainte  cont, cont2;
  Pvecteur     vect, vectp, vect2;
  Value        val, val2;
  Psyslist     lsys_aux = NULL, lsys_aux2 = NULL;
  Variable     var;
  
  if (get_debug_level() > 5)
    fprintf(stderr, "\nBuild list of min begin \n");
 
  if (lsys != NULL) {
    /* get the system corresponding to the current variable */
    sc_aux = lsys->psys;
    var = (Variable)ENTITY(CAR(lnew));
    
    if (get_debug_level() > 5) {
      fprintf(stderr, "\nSysteme en cours d'etude:");
      fprint_psysteme(stderr, sc_aux);
      fprintf(stderr, "\nVariable relative : ");
      fprint_entity_list(stderr,CONS(ENTITY, (entity)var, NIL));
      fprintf(stderr,"\nSysteme en p a ajouter: ");
      fprint_psysteme(stderr,ps);
    }
 
    if (sc_aux->nb_ineq == 1) {
      /* there is already an unique minimum */       
      vectp = vect_del_var(vect_dup((sc_aux->inegalites)->vecteur), var); 
 
      /* add inequalities on the max */
      cont = sc_aux->egalites;
      while (sc_aux->egalites != NULL) {
        cont = sc_aux->egalites;
        sc_aux->egalites = (sc_aux->egalites)->succ;
        cont->succ = NULL;
        sc_add_inegalite(sc_aux, cont);
      }
      sc_aux = sc_append(sc_aux, ps);
 
      /* put the value of the min in the equality */
      sc_add_egalite_at_end(sc_aux, contrainte_make(vectp));
      sc_aux = my_clean_ps(sc_aux);
      
      /* search on the next t variable */
      lsys_aux2 = build_list_of_min(lsys->succ, lnew->cdr, sc_aux);
 
      if (lsys_aux2 != NULL)
        lsys_aux = add_sclist_to_sclist(lsys_aux, lsys_aux2);
      else
        lsys_aux = add_sc_to_sclist(sc_aux, lsys_aux);
    }
    else {
      for (cont = sc_aux->inegalites; cont != NULL; cont = cont->succ) {
        /* for each possible minimum build new system */
        ps_aux2 = sc_dup(sc_aux);
        vect = vect_dup(cont->vecteur);
        val = vect_coeff(var, vect); 
        vectp = vect_del_var(vect_dup(cont->vecteur), var); 
        
        /* include new value of the min in the system */
        for (cont2 = ps_aux2->inegalites; cont2 != NULL; cont2 = cont2->succ) {
          vect2 = cont2->vecteur;
          val2 = vect_coeff(var, vect2);
          vect2 = vect_del_var(vect2, var);
          vect2 = vect_multiply(vect2, value_abs(val));
          vect2 = vect_add(vect_multiply(vect_dup(vectp), val2), vect2);
          cont2->vecteur = vect2;
        }      
        /* put the inequality on the current minimum */ 
        sc_add_inegalite(ps_aux2, contrainte_make(vect));
 
        /* add inequalities on the max */
        cont2 = ps_aux2->egalites;
        while (ps_aux2->egalites != NULL) {
          cont2 = ps_aux2->egalites;
          cont2->succ = NULL;
          sc_add_inegalite(ps_aux2, cont2);
          ps_aux2->egalites = (ps_aux2->egalites)->succ;
        }
 
        ps_aux2 = sc_append(ps_aux2, sc_dup(ps));
 
        /* put the minimum value that is the l in "t = omega*to + l" */
        /* in the equality part of the system. Problem if val != 1   */
        sc_add_egalite_at_end(ps_aux2, contrainte_make(vectp));
 
        sc_normalize(ps_aux2);
 
        /* get the next dimension */
        lsys_aux2 = build_list_of_min(lsys->succ, lnew->cdr, ps_aux2);
 
        if (lsys_aux2 != NULL)
          lsys_aux = add_sclist_to_sclist(lsys_aux, lsys_aux2);
        else
          lsys_aux = add_sc_to_sclist(ps_aux2, lsys_aux);
      }
    }
  }
  
  if (get_debug_level() > 5) {
    fprintf(stderr, "\n Liste de systeme build part min : ");
    sl_fprint(stderr, lsys, entity_local_name);
  }
  
  return(lsys_aux);
}

References add_sc_to_sclist(), add_sclist_to_sclist(), CAR, cons::cdr, CONS, contrainte_make(), Ssysteme::egalites, ENTITY, entity_local_name(), fprint_entity_list(), fprint_psysteme(), fprintf(), get_debug_level(), Ssysteme::inegalites, my_clean_ps(), Ssysteme::nb_ineq, NIL, sc_add_egalite_at_end(), sc_add_inegalite(), sc_append(), sc_dup(), sc_normalize(), sl_fprint(), Scontrainte::succ, value_abs, vect_add(), vect_coeff(), vect_del_var(), vect_dup(), vect_multiply(), and Scontrainte::vecteur.

Referenced by prepare_reindexing().

Here is the call graph for this function:

Here is the caller graph for this function:

build_local_time_test()

instruction build_local_time_test	(	entity	t,
		list	l
	)

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

instruction build_local_time_test(t, l)

Builds the insruction corresponding to: IF t_local > ub THEN t_local = -1 ENDIF

t = entity of the local time; l = list of the ub (expression);

AC 94/06/14

build the expression t-local = -1

make the test expression

Definition at line 471 of file reindexing.c.

{
  expression  upper = EXPRESSION(CAR(l)), exp;
  instruction ins;
  call        ca;
  list        lexp;
  statement   stat;
 
  /* build the expression t-local = -1 */
  lexp = CONS(EXPRESSION, make_entity_expression(t, NIL), NIL);
  ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, int_to_expression(-1));
  ca = make_call(entity_intrinsic(ASSIGN_OPERATOR_NAME), lexp);
  ins = make_instruction(is_instruction_call, ca);
  stat = MAKE_STATEMENT(ins);
 
  /* make the test expression */
  lexp = CONS(EXPRESSION, make_entity_expression(t, NIL), NIL);
  ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, upper);
  ca = make_call(entity_intrinsic(GREATER_THAN_OPERATOR_NAME), lexp);
  exp = make_expression(make_syntax(is_syntax_call, ca), normalized_undefined);
  
  ins = make_instruction(is_instruction_test, 
                         make_test(exp, stat, make_empty_statement()));
  
  return(ins);
}

References ADD_ELEMENT_TO_LIST, ASSIGN_OPERATOR_NAME, CAR, CONS, entity_intrinsic(), exp, EXPRESSION, GREATER_THAN_OPERATOR_NAME, int_to_expression(), is_instruction_call, is_instruction_test, is_syntax_call, lexp, make_call(), make_empty_statement, make_entity_expression(), make_expression(), make_instruction(), MAKE_STATEMENT, make_syntax(), make_test(), NIL, and normalized_undefined.

Referenced by build_third_comb().

Here is the call graph for this function:

Here is the caller graph for this function:

dataflows_on_reference()

list dataflows_on_reference	(	list	cls,
		reference	crhs,
		predicate	pred,
		list *	lm
	)

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

list dataflows_on_reference(cls, crhs, pred, lm)

Selects in the list of successors cls the one that correspond to the domain pred on which we are working and for the current rhs. The list lm will contain the corresponding list of statement of the choosen dataflow.

AC 94/04/06

Definition at line 398 of file reindexing.c.

{
  Psysteme  psd = sc_dup(predicate_to_system(pred)), sys_pred;
  list      ldata, ldat, lpred, ld;
  int       stat_pred;
  vertex    vert_pred;
 
  ldat = NIL;
  *lm = NIL;
  ldata = NIL; ld = NIL;
 
  if (get_debug_level() > 6) {
    fprintf(stderr, "\nDataflow on reference %s debut:",
            entity_local_name(reference_variable(crhs)));
    fprintf(stderr, "\nDomain noeud:");
    fprint_psysteme(stderr, psd);
  }
 
  for (lpred = cls; lpred != NIL; POP(lpred)) {
    successor suc = SUCCESSOR(CAR(lpred));
    vert_pred = successor_vertex(suc);
    stat_pred = vertex_int_stmt(vert_pred);
    
    if (get_debug_level() > 6)
      fprintf(stderr,"\nSuccesseur en cours : %d\n",stat_pred);
 
    ldata = dfg_arc_label_dataflows(successor_arc_label(suc));
 
    for (ld = ldata; ld != NIL; POP(ld)) {
      dataflow d = DATAFLOW(CAR(ld));
      sys_pred = sc_dup(predicate_to_system(dataflow_governing_pred(d)));
      if (get_debug_level() > 6) {
        fprintf(stderr, "\nDomain arc:");
        fprint_psysteme(stderr, sys_pred);
      }
      sys_pred = sc_append(sys_pred, psd);
      sc_normalize(sys_pred);
 
      if (reference_equal_p(crhs, dataflow_reference(d))) {
        if (SC_RN_P(sys_pred) ||
            sc_rational_feasibility_ofl_ctrl(sys_pred, NO_OFL_CTRL, true)) {
          if (get_debug_level() > 6) {
            fprintf(stderr, "\nDomain inter donc faisabilite:");
            fprint_psysteme(stderr, sys_pred);
          }
          ADD_ELEMENT_TO_LIST(ldat, DATAFLOW, d);
          ADD_ELEMENT_TO_LIST(*lm, INT, stat_pred);
        }
      }
    }
  }
 
  if (get_debug_level() > 6)
    fprintf(stderr, "\nDataflow on ref fin\n");
 
  return(ldat); 
}

References ADD_ELEMENT_TO_LIST, CAR, DATAFLOW, dataflow_governing_pred, dataflow_reference, dfg_arc_label_dataflows, entity_local_name(), fprint_psysteme(), fprintf(), get_debug_level(), INT, NIL, NO_OFL_CTRL, POP, predicate_to_system(), reference_equal_p(), reference_variable, sc_append(), sc_dup(), sc_normalize(), sc_rational_feasibility_ofl_ctrl(), SUCCESSOR, successor_arc_label, successor_vertex, and vertex_int_stmt().

Referenced by build_third_comb(), and build_third_subcomb().

Here is the call graph for this function:

Here is the caller graph for this function:

get_number_of_ins()

int get_number_of_ins

(

entity

e

)

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

int get_number_of_ins(e): gives back the number of the node.

AC 94/07/28

Definition at line 638 of file reindexing.c.

{
  int       n = 0;
  char      *c;
 
  c = (char*) malloc(32);
 
  c = strcpy(c, (entity_local_name(e)+4));
  n = atoi(c) + BASE_NODE_NUMBER;
 
  if (get_debug_level() > 5)
    fprintf(stderr,"\nNumero de l'instruction de %s = %d",
            entity_local_name(e), n);
  
  free(c);
 
  return(n);
}

References BASE_NODE_NUMBER, entity_local_name(), fprintf(), free(), get_debug_level(), and malloc().

Referenced by reference_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

get_time_ent()

entity get_time_ent	(	int	st,
		char *	typ,
		int	count
	)

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

entity get_time_ent(typ, count)

Returns the entity that represents the global time variable "t_count" for the program. If it does not exist yet, we create it. AC 94/05/30

AP 95/04/20: entities must have in their full name the current module name instead of RE_MODULE_NAME.

full_name = strdup(concatenate(RE_MODULE_NAME, MODULE_SEP_STRING, name, NULL));

We create it, if it does not exist yet

Definition at line 156 of file reindexing.c.

{
  char    name[32], *full_name;
  entity  new_coeff;
 
  if (!strncmp(typ, STRING_BDT, 1))
    sprintf(name, "%s%d%s%d", STAT_SYM, st, typ, count);
  else
    sprintf(name, "%s%d%s%d", STAT_SYM, st - BASE_NODE_NUMBER, typ, count);
 
  /* full_name = strdup(concatenate(RE_MODULE_NAME, MODULE_SEP_STRING,
      name, NULL));
   */
  full_name = strdup(concatenate(strdup(db_get_current_module_name()),
                                 MODULE_SEP_STRING, name, NULL));
 
  new_coeff = gen_find_tabulated(full_name, entity_domain);
 
  /* We create it, if it does not exist yet */
  if (new_coeff == entity_undefined) {
    if (!strncmp(typ, STRING_BDT, 1))
      new_coeff = create_new_entity(st, STRING_BDT, count);
    else
      new_coeff = create_new_entity(st - BASE_NODE_NUMBER,
                                    STRING_TAU, count);
  }
  
  return(new_coeff);
}

References BASE_NODE_NUMBER, concatenate(), count, create_new_entity(), db_get_current_module_name(), entity_domain, entity_undefined, full_name, gen_find_tabulated(), MODULE_SEP_STRING, STAT_SYM, strdup(), STRING_BDT, and STRING_TAU.

Referenced by build_contraction_matrices(), build_first_comb(), build_third_comb(), and re_do_it().

Here is the call graph for this function:

Here is the caller graph for this function:

make_increment_instruction()

instruction make_increment_instruction	(	entity	t,
		int	i
	)

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

instruction make_increment_instruction(t, i): returns the instruction: t = t + i

AC 94/06/09

Definition at line 610 of file reindexing.c.

{
 call        ca;
 expression  exp1;
 list        lexp;
 
 lexp = CONS(EXPRESSION, make_entity_expression(t, NIL), NIL);
 ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, int_to_expression(i));
 ca = make_call(entity_intrinsic(PLUS_OPERATOR_NAME), lexp);
 exp1 = make_expression(make_syntax(is_syntax_call, ca), 
                        normalized_undefined);
 
 lexp = CONS(EXPRESSION, make_entity_expression(t, NIL), NIL);
 ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, exp1);
 ca = make_call(entity_intrinsic(ASSIGN_OPERATOR_NAME), lexp);
 
 return(make_instruction(is_instruction_call, ca));
}

References ADD_ELEMENT_TO_LIST, ASSIGN_OPERATOR_NAME, CONS, entity_intrinsic(), EXPRESSION, int_to_expression(), is_instruction_call, is_syntax_call, lexp, make_call(), make_entity_expression(), make_expression(), make_instruction(), make_syntax(), NIL, normalized_undefined, and PLUS_OPERATOR_NAME.

Referenced by build_flag_test(), build_third_comb(), and re_do_it().

Here is the call graph for this function:

Here is the caller graph for this function:

make_init_time()

instruction make_init_time	(	entity	en,
		expression	ex
	)

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

instruction make_init_time(en, ex) : build the instruction: en = ex

AC 94/06/15

Definition at line 588 of file reindexing.c.

{
 call        ca;
 list        lexp = NIL;
 
 lexp = CONS(EXPRESSION, make_entity_expression(en, NIL), NIL);
 ADD_ELEMENT_TO_LIST(lexp, EXPRESSION, ex);
 ca = make_call(entity_intrinsic(ASSIGN_OPERATOR_NAME), lexp);
 
 return(make_instruction(is_instruction_call, ca));
}

References ADD_ELEMENT_TO_LIST, ASSIGN_OPERATOR_NAME, CONS, entity_intrinsic(), EXPRESSION, is_instruction_call, lexp, make_call(), make_entity_expression(), make_instruction(), and NIL.

Referenced by build_first_comb(), and build_third_comb().

Here is the call graph for this function:

Here is the caller graph for this function:

reindexing()

bool reindexing

(

char*

mod_name

)

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

void reindexing((char*) mod_name):

Initialize debugging functions

We get the required data: module entity, code, static_control,

dataflow graph.

mod_stat = copy_statement((statement) db_get_memory_resource(DBR_CODE, mod_name, true));

The DFG, the BDT and the PLC

First we count the number of nodes to initialize the hash tables

The temporary variables counter

Remove the old code:

And replace it by the new one:

print the values of the delay

Parameters

mod_name

odule

Definition at line 664 of file reindexing.c.

{
  extern int tc;
 
  graph           the_dfg;
  bdt             the_bdt;
  plc             the_plc;
  entity          ent;
  static_control  stco;
  statement       mod_stat, new_mod_stat;
  int nb_nodes;
  list l;
  statement_mapping STS;
 
  /* Initialize debugging functions */
  debug_on("REINDEXING_DEBUG_LEVEL");
  if (get_debug_level() > 0)
    user_log("\n\n *** COMPUTE REINDEXING for %s\n", mod_name);
 
  /* We get the required data: module entity, code, static_control, */
  /* dataflow graph.  */
  ent = local_name_to_top_level_entity( mod_name );
 
  if (ent != get_current_module_entity())
  {
    reset_current_module_entity();
    set_current_module_entity(ent);
  }
 
  /* mod_stat = copy_statement((statement) db_get_memory_resource(DBR_CODE, mod_name,
     true));*/
  mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, false);
  STS = (statement_mapping)db_get_memory_resource(DBR_STATIC_CONTROL,
                                           mod_name, false);
  set_current_stco_map(STS);
  stco = get_stco_from_current_map(mod_stat);
 
  lparams = static_control_params(stco);
 
  if (stco == static_control_undefined) 
    pips_internal_error("This is an undefined static control !");
  
  if (!static_control_yes(stco)) 
    pips_internal_error("This is not a static control program !");
  
 
  /* The DFG, the BDT and the PLC */
  the_dfg = (graph)db_get_memory_resource(DBR_ADFG, mod_name, true);
  the_bdt = (bdt)db_get_memory_resource(DBR_BDT, mod_name, true);
  the_plc = (plc)db_get_memory_resource(DBR_PLC, mod_name, true);
 
  if (get_debug_level() > 0)  
  {
    fprint_dfg(stderr, the_dfg);
    fprint_bdt(stderr, the_bdt);
    fprint_plc(stderr, the_plc);
  }
 
  /* First we count the number of nodes to initialize the hash tables */
  nb_nodes = 0;
  for(l = graph_vertices(the_dfg); !ENDP(l); POP(l))
    nb_nodes++;
  h_node = hash_table_make(hash_int, nb_nodes+1);
  delay_table = hash_table_make(hash_int, nb_nodes+1);
  ht_ab = hash_table_make(hash_int, nb_nodes+1);
 
  /* The temporary variables counter */
  tc = 0;
 
  new_mod_stat = re_do_it(the_dfg, the_bdt, the_plc);
 
  /* Remove the old code: */
  free_instruction(statement_instruction(mod_stat));
  /* And replace it by the new one: */
  statement_instruction(mod_stat) = make_instruction_block(CONS(STATEMENT,
                                                                new_mod_stat,
                                                                NIL));
  DB_PUT_MEMORY_RESOURCE(DBR_REINDEXED_CODE, strdup(mod_name),
                         (char*) mod_stat);
  reset_current_module_statement(); 
  set_current_module_statement((statement) 
                               db_get_memory_resource(DBR_CODE, 
                                                      mod_name, true) ); 
  mod_stat = get_current_module_statement(); 
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(mod_name), (char*) mod_stat); 
  reset_current_module_statement(); 
 
  /* print the values of the delay */
  if (get_debug_level() > 0)
    fprint_delay(stderr, the_dfg, delay_table);
 
  if(get_debug_level() > 0)
    user_log("\n\n *** REINDEXING done\n");
 
  hash_table_free(h_node);
  hash_table_free(delay_table);
 
  reset_current_stco_map();
  reset_current_module_entity();
 
  debug_off();
 
  return(true);
}

References CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, delay_table, ENDP, fprint_bdt(), fprint_delay(), fprint_dfg(), fprint_plc(), free_instruction(), get_current_module_entity(), get_current_module_statement(), get_debug_level(), get_stco_from_current_map(), graph_vertices, h_node, hash_int, hash_table_free(), hash_table_make(), ht_ab, local_name_to_top_level_entity(), lparams, make_instruction_block(), mod_stat, nb_nodes, NIL, pips_internal_error, POP, re_do_it(), reset_current_module_entity(), reset_current_module_statement(), reset_current_stco_map(), set_current_module_entity(), set_current_module_statement(), set_current_stco_map(), STATEMENT, statement_instruction, static_control_params, static_control_undefined, static_control_yes, strdup(), STS, tc, the_bdt, the_dfg, and user_log().

Here is the call graph for this function:

Variable Documentation

delay_table

hash_table delay_table

Name : delay.c Package : reindexing Author : Alexis Platonoff Date : March 1995 Historic :

Documents: SOON Comments : This file contains the functions dealing with the dealy. Ansi includes
Newgen includes
C3 includes
Pips includes
External variables

Definition at line 109 of file reindexing.c.

Referenced by build_first_comb(), calculate_delay(), fprint_delay(), make_array_bounds(), re_do_it(), reference_filter(), and reindexing().

h_node

hash_table h_node

Definition at line 108 of file reindexing.c.

Referenced by make_array_bounds(), make_reindex(), prepare_reindexing(), re_do_it(), and reindexing().

ht_ab

hash_table ht_ab

Definition at line 110 of file reindexing.c.

Referenced by make_array_bounds(), prepare_array_bounds(), and reindexing().

lparams

list lparams

Array bounds.

Definition at line 111 of file reindexing.c.

Referenced by freia_add_image_arguments(), freia_create_helper_function(), freia_spoc_pipeline(), freia_substitute_by_helper_call(), freia_trpx_compile_one_dag(), generic_c_words_simplified_entity(), opencl_compile_mergeable_dag(), overloaded_parameters_p(), prepare_reindexing(), print_parallelizedCMF_code(), print_parallelizedCRAFT_code(), re_do_it(), reindexing(), sc_kernel_specific_agent(), and sigmac_params_decl().

tc

int tc

static

Internal variables

Global variables

Definition at line 107 of file reindexing.c.

Referenced by array_access_to_array_ranges(), constraints_sort_info(), make_tile_constraints(), recursive_filter_formal_context_according_to_actual_context(), reference_to_points_to_translations(), reindexing(), set_dimensions_of_local_variable_family(), set_dimensions_of_local_variables(), template_cell_local_mapping(), update_common_sizes(), UpdateAbstractEntity(), UpdateDerivedEntity(), and UpdateEntity().