conversion.h File Reference

#include "matrice.h"

Include dependency graph for conversion.h:

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

Go to the source code of this file.

Functions
void	derive_new_basis (Pbase, Pbase *, entity(*)(entity))
	Warning! Do not modify this file that is automatically generated! More...
void	change_of_base_index (Pbase, Pbase *)
	void change_of_base_index(Pbase base_oldindex, Pbase *base_newindex) change of variable index from base_oldindex to base_newindex More...
entity	make_index_prime_entity (entity)
entity	make_index_entity (entity)
Psysteme	sc_change_baseindex (Psysteme, Pbase, Pbase)
	Psysteme sc_change_baseindex(Psysteme sc, Pbase base_old, Pbase base_new) le changement de base d'indice pour sc. More...
void	scanning_base_to_vect (matrice, int, Pbase, Pvecteur[])
	code_change_of_basis.c More...
Pvecteur	vect_change_base (Pvecteur, Pbase, Pvecteur[])
cons *	listexpres_to_listexpres_newbase (cons *, Pvecteur[], Pbase)
expression	expression_to_expression_newbase (expression, Pvecteur[], Pbase)
void	statement_newbase (statement, Pvecteur[], Pbase)
Psysteme	loop_iteration_domaine_to_sc (list, Pbase *)
	loop_iteration_domaine_to_sc.c More...
void	loop_index_domaine_to_contrainte (range, entity, Psysteme)
void	look_for_nested_loop_statements (statement, statement(*)(list, bool(*)(statement)), bool(*)(statement))
	look_for_nested_loops.c More...
statement	look_for_inner_loops (loop, list, statement(*)(list, bool(*)(statement)), bool(*)(statement))
	FI: I do not understand how debug levels are managed... More...
void	look_for_nested_loops_unstructured (unstructured, statement(*)(list, bool(*)(statement)), bool(*)(statement))
	oid look_for_nested_loops_unstructured(unstructured u) search the nested loops contained in the unstructured u More...
expression	Psysteme_to_expression (Psysteme)
	system_to_code.c More...
list	Pcontrainte_to_expression_list (Pcontrainte, entity)
void	set_information_for_code_optimizations (Psysteme)
	I could keep the system for further optimizations... More...
void	reset_information_for_code_optimizations (void)
expression	constraints_to_loop_bound (Pcontrainte, Variable, bool, entity)
	expression constraints_to_loop_bound(c, var, is_lower) More...
bool	bounds_equal_p (Variable, Pcontrainte, Pcontrainte)
	this function checks whether the lower and upper constraints are going to generate the same bound on variable var. More...
statement	systeme_to_loop_nest (Psysteme, list, statement, entity)
	sc is used to generate the loop nest bounds for variables vars. More...
statement	generate_optional_if (Psysteme, statement)
	statement generate_optional_if(sc, stat) More...

Function Documentation

bounds_equal_p()

bool bounds_equal_p	(	Variable	var,
		Pcontrainte	lower,
		Pcontrainte	upper
	)

this function checks whether the lower and upper constraints are going to generate the same bound on variable var.

oeff for var in the constraint

??? the arithmetic ppcm version is on int instead of values

Parameters

var	ar
lower	ower
upper	pper

Definition at line 534 of file system_to_code.c.

{
    Pvecteur v_lower, v_upper, sum;
    Value val_lower, val_upper, the_ppcm;
    bool result;
 
    if (nb_elems_list(lower)!=1 || nb_elems_list(upper)!=1) return(false);
 
    val_upper = vect_coeff(var, upper->vecteur); /*coeff for var in the constraint*/
    val_lower = vect_coeff(var, lower->vecteur);
    
    /* ??? the arithmetic ppcm version is on int instead of values 
     */
    the_ppcm = ppcm(value_uminus(val_lower), val_upper);
 
    v_lower = vect_dup(lower->vecteur);
    v_lower = vect_multiply(v_lower, 
                            value_div(value_uminus(the_ppcm),val_lower));
 
    v_upper = vect_dup(upper->vecteur);
    v_upper = vect_multiply(v_upper, 
                            value_div(the_ppcm,val_upper));
 
    sum = vect_add(v_lower, v_upper);
    vect_add_elem(&sum, TCST, value_minus(the_ppcm,VALUE_ONE));
    vect_normalize(sum);
 
    result = VECTEUR_NUL_P(sum) || 
        (sum->succ==NULL && var_of(sum)==TCST && val_of(sum)==0);
 
    vect_rm(v_lower), vect_rm(v_upper), vect_rm(sum);
 
    return result;
}

References nb_elems_list(), ppcm(), sum(), TCST, val_of, value_div, value_minus, VALUE_ONE, value_uminus, var_of, vect_add(), vect_add_elem(), vect_coeff(), vect_dup(), vect_multiply(), vect_normalize(), vect_rm(), Scontrainte::vecteur, and VECTEUR_NUL_P.

Referenced by region_to_minimal_dimensions(), and systeme_to_loop_nest().

Here is the call graph for this function:

Here is the caller graph for this function:

change_of_base_index()

void change_of_base_index	(	Pbase	base_oldindex,
		Pbase *	base_newindex
	)

void change_of_base_index(Pbase base_oldindex, Pbase *base_newindex) change of variable index from base_oldindex to base_newindex

Parameters

base_oldindex	ase_oldindex
base_newindex	ase_newindex

Definition at line 65 of file change_of_Pbase.c.

{
    derive_new_basis(base_oldindex, base_newindex, make_index_prime_entity);
}

References derive_new_basis(), and make_index_prime_entity().

Referenced by hyperplane(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function:

constraints_to_loop_bound()

expression constraints_to_loop_bound	(	Pcontrainte	c,
		Variable	var,
		bool	is_lower,
		entity	divide
	)

expression constraints_to_loop_bound(c, var, is_lower)

the is_lower (lower/upper) loop bound for variable var relative to Pcontrainte c is generated. All the constraints in c are used, and they must be ok.

see also make_bound_expression in ri-util/bound_generation.c maybe move this function in ri-util/bound_generation.c? integer division to be called

the constraints are sorted first, to ensure a deterministic result ??? the sorting criterion is rather strange:-)

each constraint is considered in turn to generate a bound

ax+b <= 0 and a<0 => x >= (b+(-a-1))/(-a)

extract coefficients that are dividable by val... x = (ay+bz)/a -> x = y + bz/a

assert. no a.i=0 should have reached this point...

I perform some other optimizations here, by looking at the extent of the numerator, that may result in a constant after division by the denominator. For instance, x = y/a and 0 <= y < a would lead to x = 0, which is quite simpler... I need a hook from the callers of this function to retrieve the constant lower and upper bounds of each variable in order to perform this. ??? this optimizations should/could be perform earlier on the original system... but the implementation in a general context does not seems obvious to me...

use / instead of the provided idiv if operand >=0

final operation: MAX or MIN if more than one bound

and memory leak... (cons lost)

Parameters

var	the constraints of the bound
is_lower	the index variable
divide	lower or upper bound

Definition at line 374 of file system_to_code.c.

{
  int len = 0, sign = is_lower? -1: +1;
  expression result = expression_undefined;
  list le = NIL;
  Psysteme s;
  
  pips_debug(5, "computing %ser bound for variable %s\n",
             (is_lower?"low":"upp"), entity_local_name((entity) var));
 
  ifdebug(6)
  {
      fprintf(stderr, "[constraints_to_loop_bound] constraints are:\n");
      inegalites_fprint(stderr, c, (get_variable_name_t) entity_local_name);
  }
 
  message_assert("some constraints", !CONTRAINTE_UNDEFINED_P(c));
 
  /*  the constraints are sorted first, to ensure a deterministic result
   *  ??? the sorting criterion is rather strange:-)
   */
  s = sc_make(NULL, contraintes_dup(c));
  vect_sort(sc_base(s), compare_Pvecteur);
  sc_sort_constraints(s, sc_base(s));
  
  /*  each constraint is considered in turn to generate a bound
   */
  for(c=sc_inegalites(s); c; c=c->succ)
  {
      Value val = vect_coeff(var, c->vecteur), computed;
      Pvecteur vdiv = vect_del_var(c->vecteur, var), vadd = VECTEUR_NUL, v;
      expression ediv, eadd, e;
 
      message_assert("coherent value and sign", sign*value_sign(val)>0);
 
      if (value_pos_p(val)) 
          vect_chg_sgn(vdiv);
      else
          /*  ax+b <= 0 and a<0 => x >= (b+(-a-1))/(-a)
           */
          value_oppose(val), 
          vect_add_elem(&vdiv, TCST, value_minus(val,VALUE_ONE));
 
      if (value_one_p(val))
      {
          le = CONS(EXPRESSION, make_vecteur_expression(vdiv), le);
          continue;
      }
 
      /* extract coefficients that are dividable by val...
       * x = (ay+bz)/a -> x = y + bz/a
       */
      for (v=vdiv; v; v=v->succ)
      {
          Variable va = var_of(v);
          Value vl = val_of(v);
 
          if (value_zero_p(value_mod(vl,val))) 
              vect_add_elem(&vadd, va, value_div(vl,val));
      }
 
      for (v=vadd; v; v=v->succ)
          vect_erase_var(&vdiv, var_of(v));
 
      /* assert. no a.i=0 should have reached this point...
       */
      message_assert("some expression", vdiv || vadd);
 
      /* I perform some other optimizations here, by looking at
       * the extent of the numerator, that may result in a constant after
       * division by the denominator. For instance, x = y/a and 0 <= y < a
       * would lead to x = 0, which is quite simpler... I need a hook
       * from the callers of this function to retrieve the constant lower
       * and upper bounds of each variable in order to perform this.
       * ??? this optimizations should/could be perform earlier on 
       * the original system... but the implementation in a general context
       * does not seems obvious to me...
       */
      if (evaluate_divide_if_possible(vdiv, val, &computed))
      {
          vect_rm(vdiv), vdiv=VECTEUR_NUL;
          vect_add_elem(&vadd, TCST, computed);
      }
 
      if (vdiv)
      {
          ediv = make_vecteur_expression(vdiv);
 
          /* use / instead of the provided idiv if operand >=0
           */
          ediv = MakeBinaryCall(value_posz_p(vecteur_lower_bound(vdiv)) ? 
                                entity_intrinsic(DIVIDE_OPERATOR_NAME) : 
                                divide, ediv, Value_to_expression(val));
          
          if (vadd)
          {
              eadd = make_vecteur_expression(vadd);
              e = MakeBinaryCall(entity_intrinsic(PLUS_OPERATOR_NAME),
                                 eadd, ediv);
          }
          else
              e = ediv;
      }
      else 
          e = make_vecteur_expression(vadd);
 
      vect_rm(vdiv), vect_rm(vadd);
      le = CONS(EXPRESSION, e, le);
  }
 
  /* final operation: MAX or MIN if more than one bound
   */
  // Added an option to automatically take the constant value over the other expressions
  // Should not affect the function unless the property is set to True (False by default)
  len = gen_length(le);  message_assert("some expressions", len!=0);
 
  if (len==1)
  {
      result = EXPRESSION(CAR(le)); /* and memory leak... (cons lost) */
      gen_free_list(le);
  }
  else if (get_bool_property("PSYSTEME_TO_LOOPNEST_FOR_RSTREAM")) {
    int nb_constant = 0;
    FOREACH(expression, exp, le) {
      if (expression_constant_p(exp)) {
        result = exp;
        nb_constant++;
      }
    }
    gen_free_list(le);
    pips_assert("More than one constant expression in loop bounds", nb_constant == 1);
  }
  else
  {
    if(false && c_language_module_p(get_current_module_entity())) {
      entity operator = entity_intrinsic(is_lower ? PIPS_C_MAX_OPERATOR_NAME : PIPS_C_MIN_OPERATOR_NAME);
      int c = gen_length(le);
      expression ce = int_to_expression(c);
      le = CONS(EXPRESSION, ce, le);
      result = make_call_expression(operator, le);
    }
    else { // Fortran case
      entity operator = entity_intrinsic(is_lower ? MAX_OPERATOR_NAME : MIN_OPERATOR_NAME);
      result = make_call_expression(operator, le);
    }
  }
 
  sc_rm(s);
 
  return result;
}

References c_language_module_p(), CAR, compare_Pvecteur(), CONS, CONTRAINTE_UNDEFINED_P, contraintes_dup(), divide, DIVIDE_OPERATOR_NAME, entity_intrinsic(), entity_local_name(), evaluate_divide_if_possible(), exp, EXPRESSION, expression_constant_p(), expression_undefined, FOREACH, fprintf(), gen_free_list(), gen_length(), get_bool_property(), get_current_module_entity(), ifdebug, inegalites_fprint(), int_to_expression(), make_call_expression(), make_vecteur_expression(), MakeBinaryCall(), MAX_OPERATOR_NAME, message_assert, MIN_OPERATOR_NAME, NIL, pips_assert, PIPS_C_MAX_OPERATOR_NAME, PIPS_C_MIN_OPERATOR_NAME, pips_debug, PLUS_OPERATOR_NAME, sc_make(), sc_rm(), sc_sort_constraints(), Scontrainte::succ, Svecteur::succ, TCST, val_of, value_div, value_minus, value_mod, VALUE_ONE, value_one_p, value_oppose, value_pos_p, value_posz_p, value_sign, Value_to_expression(), value_zero_p, var_of, vect_add_elem(), vect_chg_sgn(), vect_coeff(), vect_del_var(), vect_erase_var(), vect_rm(), vect_sort(), Scontrainte::vecteur, vecteur_lower_bound(), and VECTEUR_NUL.

Referenced by do_array_expansion(), do_check_isolate_statement_preconditions_on_call(), do_isolate_statement_preconditions_satisified_p(), do_solve_hardware_constraints_on_nb_proc(), make_rectangular_area(), region_to_minimal_dimensions(), statement_insertion_fix_access(), systeme_to_loop_nest(), and variable_to_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

derive_new_basis()

void derive_new_basis	(	Pbase	base_oldindex,
		Pbase *	base_newindex,
		entity(*)(entity)	new_entity
	)

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

Modify src/Libs/conversion/conversion-local.h instead, to add your own modifications. header file built by cproto conversion-local.h cproto-generated files change_of_Pbase.c

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

Parameters

base_oldindex	ase_oldindex
base_newindex	ase_newindex

Definition at line 48 of file change_of_Pbase.c.

{
    Pbase pb;
    entity new_name;
 
    for (pb=base_oldindex; pb!=NULL; pb=pb->succ)
    {
        new_name = new_entity((entity) pb->var);
        base_add_dimension(base_newindex, (Variable) new_name);
    }
    *base_newindex = base_reversal(*base_newindex);
}

References base_add_dimension, base_reversal(), Svecteur::succ, and Svecteur::var.

Referenced by change_of_base_index(), parallel_tiling(), and tiling_transformation().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_expression_newbase()

expression expression_to_expression_newbase	(	expression	,
		Pvecteur	[],
		Pbase
	)

generate_optional_if()

statement generate_optional_if	(	Psysteme	sc,
		statement	stat
	)

statement generate_optional_if(sc, stat)

if sc is Z^n then no if is required, if sc is empty, then statement is nop, else an if is required

Parameters

sc	c
stat	tat

Definition at line 667 of file system_to_code.c.

{
    if (sc_rn_p(sc)) return(stat);
    if (sc_empty_p(sc)) return(make_empty_statement());
 
    return st_make_nice_test(Psysteme_to_expression(sc),
                             CONS(STATEMENT, stat, NIL),
                             NIL);
}

References CONS, make_empty_statement, NIL, Psysteme_to_expression(), sc_empty_p(), sc_rn_p(), st_make_nice_test(), and STATEMENT.

Referenced by build_third_comb(), generate_io_statements_for_shared_arrays(), GENERATION(), processor_loop(), and verify_array_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

listexpres_to_listexpres_newbase()

cons* listexpres_to_listexpres_newbase	(	cons *	,
		Pvecteur	[],
		Pbase
	)

look_for_inner_loops()

statement look_for_inner_loops	(	loop	l,
		list	sl,
		statement(*)(list, bool(*)(statement))	loop_transformation,
		bool(*)(statement)	loop_predicate
	)

FI: I do not understand how debug levels are managed...

They should be factored out.

check that i is a block

SG: added to cope with empty statements

i is an inner loop, append it to the list of loops

here are no more nested loops

FI: I do not understand this piece of code. I expect a look_for_nested_loop_statements().

Parameters

sl

l

Definition at line 166 of file look_for_nested_loops.c.

{
    statement lb = loop_body(l);
    instruction i = statement_instruction(lb);
    statement ss;
    statement new_s = statement_undefined;
    unstructured unst;
    loop li;
    cons *b, *b1;
    test tt;
    statement true_s, false_s;
 
    /* check that i is a block */
    switch (instruction_tag(i)) {
 
    case is_instruction_loop:
 
        li = instruction_loop(i);
        sl = CONS(STATEMENT,lb,sl);
        new_s = look_for_inner_loops(li,sl,loop_transformation, loop_predicate);
        break;
 
    case is_instruction_block:
retry:
        b = instruction_block(i);
        ss = STATEMENT(CAR(b));
    /* SG: added to cope with empty statements */
    while(empty_statement_or_continue_p(ss) && !ENDP(CDR(b))) {
        POP(b);
        ss=STATEMENT(CAR(b));
    }
        i = statement_instruction(ss);
  if (instruction_block_p(i))
    goto retry;
  if (instruction_loop_p(i)){
    /* i is an inner loop, append it to the list of loops */
    li = instruction_loop(i);
    sl = CONS(STATEMENT,ss,sl);
    new_s = look_for_inner_loops(li, sl, loop_transformation, loop_predicate);
        }
        else {
            /*there are no more nested loops */
 
            look_for_nested_loop_statements(ss,loop_transformation, loop_predicate);
            debug_on("ZERO_DEBUG_LEVEL");
            new_s = (*loop_transformation)(sl,loop_predicate);
            debug_off();
        }
 
        for( b1=CDR(b); !ENDP(b1); b1 = CDR(b1) ) {
            ss = STATEMENT(CAR(b1));
            look_for_nested_loop_statements(ss,loop_transformation, loop_predicate);
        }
        break;
 
 
        ␌
    case is_instruction_test:
 
        tt = instruction_test(i);
        true_s = test_true(tt);
        false_s= test_false(tt);
        look_for_nested_loop_statements(true_s,loop_transformation, loop_predicate);
        look_for_nested_loop_statements(false_s,loop_transformation, loop_predicate);
        debug_on("ZERO_DEBUG_LEVEL");
        new_s = (*loop_transformation)(sl,loop_predicate);
        debug_off();
        break;
 
    case is_instruction_whileloop: {
      statement body = whileloop_body(instruction_whileloop(i));
 
      look_for_nested_loop_statements(body, loop_transformation, loop_predicate);
      new_s = (*loop_transformation)(sl,loop_predicate);
      break;
    }
 
    case is_instruction_forloop: {
      statement body = forloop_body(instruction_forloop(i));
 
      look_for_nested_loop_statements(body, loop_transformation, loop_predicate);
      new_s = (*loop_transformation)(sl,loop_predicate);
      break;
    }
    case is_instruction_goto:
 
        pips_internal_error("unexpected goto");
 
    case is_instruction_call:
        debug_on("ZERO_DEBUG_LEVEL");
        new_s = (*loop_transformation)(sl,loop_predicate);
        debug_off();
 
        break;
 
    case is_instruction_unstructured:
 
      /* FI: I do not understand this piece of code. I expect a
         look_for_nested_loop_statements(). */
        unst =instruction_unstructured(i);
        ss=control_statement(unstructured_control(unst));
        i = statement_instruction(ss);
        if (instruction_loop_p(i)) {
            li = instruction_loop(i);
            sl = CONS(STATEMENT,ss,sl);
            new_s = look_for_inner_loops(li,sl,loop_transformation, loop_predicate);
        }
        else {
            debug_on("ZERO_DEBUG_LEVEL");
            new_s = (*loop_transformation)(sl,loop_predicate);
            debug_off();
            break;
        }
        break;
 
    default:
        pips_internal_error("unexpected tag %d",instruction_tag(i));
    }
 
    return new_s;
}

References b1, CAR, CDR, CONS, control_statement, debug_off, debug_on, empty_statement_or_continue_p(), ENDP, forloop_body, instruction_block, instruction_block_p, instruction_forloop, instruction_loop, instruction_loop_p, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_block, is_instruction_call, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, look_for_inner_loops(), look_for_nested_loop_statements(), loop_body, pips_internal_error, POP, STATEMENT, statement_instruction, statement_undefined, test_false, test_true, unstructured_control, and whileloop_body.

Referenced by look_for_inner_loops(), and look_for_nested_loop_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

look_for_nested_loop_statements()

void look_for_nested_loop_statements	(	statement	s,
		statement(*)(list, bool(*)(statement))	loop_transformation,
		bool(*)(statement)	loop_predicate
	)

look_for_nested_loops.c

look_for_nested_loops.c

void look_for_nested_loop_statements(statement s) search the nested loops in the statement s

ifdebug(9) {

pips_debug(9, "Before transformation:\n");

debug_on("ZERO_DEBUG_LEVEL");

print_statement(s);

debug_off();

}

debug_on("ZERO_DEBUG_LEVEL");

print_statement(new_s);

debug_off();

SG: added to cope with empty statements

Definition at line 56 of file look_for_nested_loops.c.

{
    instruction i;
    cons *b, *b1;
    statement ss, new_s = statement_undefined;
    loop l;
    cons *list_loop_statement;
    test tt;
    statement true_s, false_s;
 
    i = statement_instruction(s);
    switch (instruction_tag(i)) {
    case is_instruction_loop:
        new_s = s;
        l = instruction_loop(i);
 
        if ((*loop_predicate)(s)) {
            list_loop_statement = CONS (STATEMENT,s,NIL);
 
            /* ifdebug(9) { */
            /*  pips_debug(9, "Before transformation:\n"); */
            /*  debug_on("ZERO_DEBUG_LEVEL"); */
            /*  print_statement(s); */
            /*  debug_off(); */
            /* } */
 
            new_s = look_for_inner_loops(l,
                                         list_loop_statement,
                                         loop_transformation,
                                         loop_predicate);
 
            ifdebug(9) {
                pips_debug(9, "After transformation:\n");
                pips_assert("look_for_nested_loop_statement", statement_consistent_p(new_s));
                /* debug_on("ZERO_DEBUG_LEVEL"); */
                /* print_statement(new_s); */
                /* debug_off(); */
            }
            if (new_s != statement_undefined) {
                i = statement_instruction(s);
                instruction_loop(i) =
                    instruction_loop(statement_instruction(new_s)); }
        }
        else look_for_nested_loop_statements(loop_body(l),loop_transformation, 
                                             loop_predicate);
        break;
 
    case is_instruction_block:
 
        b = instruction_block(i);
        if(ENDP(b)) break;
        ss = STATEMENT(CAR(b));
    /* SG: added to cope with empty statements */
    while(empty_statement_or_continue_p(ss) && !ENDP(CDR(b))) {
        POP(b);
        ss=STATEMENT(CAR(b));
    }
        look_for_nested_loop_statements(ss, loop_transformation, loop_predicate);
        for(b1 = CDR(b); !ENDP(b1); b1 = CDR(b1)) {
            ss = STATEMENT(CAR(b1));
            look_for_nested_loop_statements(ss, loop_transformation, loop_predicate);
        }
        break;
 
    case is_instruction_call:
        break;
 
    case is_instruction_test:
 
        tt = instruction_test(i);
        true_s = test_true(tt);
        false_s= test_false(tt);
        look_for_nested_loop_statements(true_s, loop_transformation, loop_predicate);
        look_for_nested_loop_statements(false_s, loop_transformation, loop_predicate);
        break;
 
    case is_instruction_whileloop: {
 
        whileloop wl = instruction_whileloop(i);
        statement body = whileloop_body(wl);
 
        look_for_nested_loop_statements(body, loop_transformation, loop_predicate);
        break;
    }
 
    case is_instruction_forloop: {
 
        forloop fl = instruction_forloop(i);
        statement body = forloop_body(fl);
 
        look_for_nested_loop_statements(body, loop_transformation, loop_predicate);
        break;
    }
 
    case is_instruction_unstructured:
        look_for_nested_loops_unstructured(instruction_unstructured(i),
                                           loop_transformation,
                                           loop_predicate);
        break;
 
    case is_instruction_goto:
        pips_internal_error("unexpected goto in code");
    default:
        pips_internal_error("unexpected tag %d",instruction_tag(i));
    }
}

References b1, CAR, CDR, CONS, empty_statement_or_continue_p(), ENDP, forloop_body, ifdebug, instruction_block, instruction_forloop, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_block, is_instruction_call, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, look_for_inner_loops(), look_for_nested_loop_statements(), look_for_nested_loops_unstructured(), loop_body, NIL, pips_assert, pips_debug, pips_internal_error, POP, STATEMENT, statement_consistent_p(), statement_instruction, statement_undefined, test_false, test_true, and whileloop_body.

Referenced by global_parallelization(), interactive_loop_transformation(), look_for_inner_loops(), look_for_nested_loop_statements(), look_for_nested_loops_unstructured(), and strip_mine().

Here is the call graph for this function:

Here is the caller graph for this function:

look_for_nested_loops_unstructured()

void look_for_nested_loops_unstructured	(	unstructured	u,
		statement(*)(list, bool(*)(statement))	loop_transformation,
		bool(*)(statement)	loop_predicate
	)

oid look_for_nested_loops_unstructured(unstructured u) search the nested loops contained in the unstructured u

Definition at line 298 of file look_for_nested_loops.c.

{
    cons *blocs = NIL;
    control ct = unstructured_control(u);
 
    debug_on("GENERATION_DEBUG_LEVEL");
    CONTROL_MAP(c, {
        statement st = control_statement(c) ;
        (void) look_for_nested_loop_statements(st,loop_transformation, loop_predicate);
    }, ct, blocs) ;
    gen_free_list(blocs);
    debug_off();
}

References CONTROL_MAP, control_statement, debug_off, debug_on, gen_free_list(), look_for_nested_loop_statements(), NIL, and unstructured_control.

Referenced by look_for_nested_loop_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_index_domaine_to_contrainte()

void loop_index_domaine_to_contrainte	(	range	r,
		entity	ind,
		Psysteme	sc
	)

ake two constraints for the current index: I-vup<=0, -I+vlow<=0

build - new_var <= 0

build incr * new_var - vup + vlow <= 0

build ind == vlow + incr * new_var

Parameters

ind	nd
sc	c

Definition at line 86 of file loop_iteration_domaine_to_sc.c.

{
    Pvecteur pv;
    Pcontrainte pc;
    Pvecteur 
        vlow = VECTEUR_NUL,
        vup = VECTEUR_NUL,
        pv_incr = VECTEUR_NUL;
 
    Value incr= VALUE_ONE;
 
    expression low = range_lower(r);
    expression up = range_upper(r);
    normalized low_norm = NORMALIZE_EXPRESSION(low);
    normalized up_norm = NORMALIZE_EXPRESSION(up);
    normalized incr_norm = NORMALIZE_EXPRESSION(range_increment(r));
 
 
    debug_on("CONVERSION_DEBUG_LEVEL");
 
    debug(8,"loop_index_domaine_to_contrainte", "begin\n");
   
    if (normalized_linear_p(low_norm) && normalized_linear_p(up_norm)){
        vlow = (Pvecteur) normalized_linear(low_norm);  
        vup = (Pvecteur) normalized_linear(up_norm);
 
    }
    else
        user_error("loop_iteration_domaine_to_sc","untractable loop bound\n");
 
    if (normalized_linear_p(incr_norm)) 
        pv_incr = (Pvecteur) normalized_linear(incr_norm);
    if (vect_constant_p(pv_incr)) {
        if (value_one_p(incr = vecteur_val(pv_incr))) {
            /*make two constraints for the current index: 
              I-vup<=0, -I+vlow<=0 */
            pv = vect_dup(vup);
            vect_chg_sgn(pv);
            vect_add_elem(&pv, (Variable) ind, VALUE_ONE);
            pc = contrainte_make(pv);
            sc_add_ineg(sc,pc);
            pv = vect_dup(vlow);
            vect_add_elem(&pv, (Variable) ind, VALUE_MONE);
            pc = contrainte_make(pv);
            sc_add_ineg(sc,pc);
        }
        else {
            Variable new_var = creat_new_var(sc);
            sc->dimension++;
            sc->base = vect_add_variable(sc->base, (Variable) new_var);
            /* build   - new_var <= 0 */
            pv = vect_new((Variable) ind, VALUE_MONE);
            pc = contrainte_make(pv);
            sc_add_ineg(sc,pc);
            /* build     incr * new_var - vup + vlow <= 0 */   
            pv = vect_dup(vup);
            vect_chg_sgn(pv);
            pv = vect_add(pv,vect_dup(vlow));
            vect_add_elem(&pv, (Variable) new_var, incr);
            pc = contrainte_make(pv);
            sc_add_ineg(sc,pc);
            /* build   ind == vlow + incr * new_var */
            pv = vect_dup(vlow);
            vect_chg_sgn(pv);
            pv = vect_add(pv,vect_new((Variable) ind, VALUE_ONE));
            pv = vect_add(pv,vect_new((Variable) new_var, value_uminus(incr)));
            pc = contrainte_make(pv);
            sc_add_eg(sc,pc);
        }
    }
 
    debug(8,"loop_index_domaine_to_contrainte", "end\n");
 
    debug_off();
}

References Ssysteme::base, contrainte_make(), creat_new_var(), debug(), debug_off, debug_on, Ssysteme::dimension, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, range_increment, range_lower, range_upper, user_error, VALUE_MONE, VALUE_ONE, value_one_p, value_uminus, vect_add(), vect_add_elem(), vect_add_variable(), vect_chg_sgn(), vect_constant_p(), vect_dup(), vect_new(), VECTEUR_NUL, and vecteur_val.

Referenced by loop_iteration_domaine_to_sc().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_iteration_domaine_to_sc()

Psysteme loop_iteration_domaine_to_sc	(	list	lls,
		Pbase *	baseindex
	)

loop_iteration_domaine_to_sc.c

loop_iteration_domaine_to_sc.c

Psysteme loop_iteration_domaine_to_sc(cons *lls , Pbase *baseindex) transform the iteration domain of the nested loops (contained lls) in a system of constraints (sc)

New loop indices are added at the head of the list baseindex. The field base of sc contains all the system variables. Variables are not in a specific order.

CA: Ajout du cas ou l'increment de boucle est different de 1 le 1/9/91

add the current index "ind" to the index basis

dd the constraints to sc

Parameters

lls	ls
baseindex	aseindex

Definition at line 52 of file loop_iteration_domaine_to_sc.c.

{
    Psysteme sc;
 
    debug_on("CONVERSION_DEBUG_LEVEL");
 
    pips_debug(8, "begin\n");
 
    sc = sc_new();
    for (; lls != NIL; lls = CDR(lls)){
        loop l = instruction_loop(statement_instruction(STATEMENT(CAR(lls))));
        entity ind = loop_index(l);
        range r = loop_range(l);
 
        /* add the current index "ind" to the index basis */    
        base_add_dimension(baseindex, (Variable) ind);
 
        /*add the constraints to sc*/
        loop_index_domaine_to_contrainte(r, ind, sc);
    }  
    sc->nb_ineq = nb_elems_list(sc->inegalites);
    sc_creer_base(sc);
 
    ifdebug(8) {
        vect_fprint(stderr, *baseindex, (get_variable_name_t) entity_local_name);
    }
 
    debug(8,"loop_iteration_domaine_to_sc", "end\n");
 
    debug_off();
    return sc;
}

References base_add_dimension, CAR, CDR, debug(), debug_off, debug_on, entity_local_name(), ifdebug, Ssysteme::inegalites, instruction_loop, loop_index, loop_index_domaine_to_contrainte(), loop_range, nb_elems_list(), Ssysteme::nb_ineq, NIL, pips_debug, sc_creer_base(), sc_new(), STATEMENT, statement_instruction, and vect_fprint().

Referenced by compute_iteration_domain(), Hierarchical_tiling(), hyperplane(), parallel_tiling(), Tiling2_buffer(), Tiling_buffer_allocation(), tiling_transformation(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function:

make_index_entity()

entity make_index_entity

(

entity

old_index

)

Parameters

old_index

ld_index

Definition at line 77 of file change_of_Pbase.c.

{
    return make_index_prime_entity(old_index);
}

References make_index_prime_entity().

Here is the call graph for this function:

make_index_prime_entity()

entity make_index_prime_entity

(

entity

old_index

)

Parameters

old_index

ld_index

Definition at line 72 of file change_of_Pbase.c.

{
  return make_new_index_entity(old_index, "p");
}

References make_new_index_entity().

Referenced by change_of_base_index(), and make_index_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

Pcontrainte_to_expression_list()

list Pcontrainte_to_expression_list	(	Pcontrainte	constraint,
		entity	operator
	)

a simple expression is generated.

a binary operator should be given, as eg, ne, lt, le, gt, ge.

Parameters

constraint	onstraint
operator	perator

Definition at line 90 of file system_to_code.c.

{
    list result = NIL;
    Pcontrainte c = NULL;
    Pvecteur vneg = VECTEUR_NUL, vpos = VECTEUR_NUL;
 
    for(c=constraint; c; c=c->succ)
      if (entity_undefined_p(operator))
 
        /* a simple expression is generated.
         */
        result = 
            CONS(EXPRESSION, 
               make_vecteur_expression(contrainte_vecteur(c)),
               result);
      else
 
        /* a binary operator should be given, as eg, ne, lt, le, gt, ge.
         */
        Pvecteur_separate_on_sign(contrainte_vecteur(c), &vpos, &vneg),
        result = 
          CONS(EXPRESSION,
               MakeBinaryCall(operator,
                              make_vecteur_expression(vpos),
                              make_vecteur_expression(vneg)),
               result),
        vect_rm(vpos), vpos=VECTEUR_NUL,
        vect_rm(vneg), vneg=VECTEUR_NUL;
    
    return result;
}

References CONS, contrainte_vecteur, entity_undefined_p, EXPRESSION, make_vecteur_expression(), MakeBinaryCall(), NIL, Pvecteur_separate_on_sign(), Scontrainte::succ, vect_rm(), and VECTEUR_NUL.

Referenced by Psysteme_to_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

Psysteme_to_expression()

expression Psysteme_to_expression

(

Psysteme

systeme

)

system_to_code.c

system_to_code.c

Psystems stuff Newgen stuff PIPS stuff expression Psysteme_to_expression(Psysteme systeme)

From a Psysteme, a logical expression that checks for the constraints is generated.

Parameters

systeme

ysteme

Definition at line 69 of file system_to_code.c.

{
    entity
        equ = entity_intrinsic(EQUAL_OPERATOR_NAME),
        leq = entity_intrinsic(LESS_OR_EQUAL_OPERATOR_NAME);
    list conjonction;
    expression result;
 
    conjonction = 
        gen_nconc
            (Pcontrainte_to_expression_list(sc_egalites(systeme), equ),
             Pcontrainte_to_expression_list(sc_inegalites(systeme), leq));
 
    result = expression_list_to_conjonction(conjonction);
 
    gen_free_list(conjonction);
    return result;
}

References entity_intrinsic(), EQUAL_OPERATOR_NAME, expression_list_to_conjonction(), gen_free_list(), gen_nconc(), LESS_OR_EQUAL_OPERATOR_NAME, and Pcontrainte_to_expression_list().

Referenced by build_third_comb(), expression_less_than_in_context(), generate_optional_if(), and top_down_abc_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_information_for_code_optimizations()

void reset_information_for_code_optimizations

(

void

)

Definition at line 254 of file system_to_code.c.

{
    close_lowers();
    close_uppers();
}

Referenced by generate_io_collect_or_update(), and hpf_remapping().

Here is the caller graph for this function:

sc_change_baseindex()

Psysteme sc_change_baseindex	(	Psysteme	sc,
		Pbase	base_old,
		Pbase	base_new
	)

Psysteme sc_change_baseindex(Psysteme sc, Pbase base_old, Pbase base_new) le changement de base d'indice pour sc.

Parameters

sc	c
base_old	ase_old
base_new	ase_new

Definition at line 85 of file change_of_Pbase.c.

{
    Pbase pb1, pb2;
 
    for(pb1=base_old,pb2=base_new;pb1!=NULL;pb1=pb1->succ,pb2=pb2->succ)
        sc_variable_rename(sc,pb1->var,pb2->var);
    return(sc);
}

References sc_variable_rename(), Svecteur::succ, and Svecteur::var.

Referenced by hyperplane(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function:

scanning_base_to_vect()

void scanning_base_to_vect	(	matrice	,
		int	,
		Pbase	,
		Pvecteur	[]
	)

code_change_of_basis.c

set_information_for_code_optimizations()

void set_information_for_code_optimizations

(

Psysteme

s

)

I could keep the system for further optimizations...

Here, only direct lower and upper bounds are extracted and kept.

first look thru equalities

then thru inequalities

UPPER

LOWER

Definition at line 208 of file system_to_code.c.

{
    Pcontrainte c;
    Variable var; 
    Value coe, cst, val;
 
    init_lowers();
    init_uppers();
 
    /* first look thru equalities
     */
    for (c=sc_egalites(s); c; c=c->succ)
    {
        if (vect_simple_definition_p(contrainte_vecteur(c), &var, &coe, &cst))
        {
            val = value_div(value_uminus(cst), coe);
            store_an_upper((entity) var, VALUE_TO_INT(val));
            store_a_lower((entity) var, VALUE_TO_INT(val));
        }
    }
 
    /* then thru inequalities
     */
    for (c=sc_inegalites(s); c; c=c->succ)
    {
        if (vect_simple_definition_p(contrainte_vecteur(c), &var, &coe, &cst))
        {
            if (value_pos_p(coe)) /* UPPER */
            {
                Value n = value_uminus(cst),
                      r = value_pdiv(n, coe);
                store_an_upper((entity) var, VALUE_TO_INT(r));
            }
            else /* LOWER */
            {
                Value n = value_minus(cst,value_plus(coe,VALUE_ONE)),
                      d = value_uminus(coe),
                      r = value_pdiv(n,d);
                store_a_lower((entity) var, VALUE_TO_INT(r));
            }
        }
    }
}

References contrainte_vecteur, store_a_lower(), store_an_upper(), Scontrainte::succ, value_div, value_minus, VALUE_ONE, value_pdiv, value_plus, value_pos_p, VALUE_TO_INT, value_uminus, and vect_simple_definition_p().

Referenced by generate_io_collect_or_update(), and hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_newbase()

void statement_newbase	(	statement	,
		Pvecteur	[],
		Pbase
	)

systeme_to_loop_nest()

statement systeme_to_loop_nest	(	Psysteme	sc,
		list	vars,
		statement	body,
		entity	divide
	)

sc is used to generate the loop nest bounds for variables vars.

vars may be empty. the loop statement is returned.

sc is not touched... I have to give the divide entity to be called

duplicate sc

??? could do a better job with =

reverse the list of vars

VAR = LOWER body

DO VAR = LOWER, UPPER, 1 body ENDDO

Parameters

sc	c
vars	of entity
body	ody
divide	ivide

Definition at line 578 of file system_to_code.c.

{
    range rg;
    Pcontrainte c, lower, upper;
    list reverse;
    statement assign, current = body;
    Psysteme s;
 
    if (ENDP(vars)) return body;
 
    s = sc_dup(sc);   /* duplicate sc*/
    sc_transform_eg_in_ineg(s);  /* ??? could do a better job with = */
    c = sc_inegalites(s);    
 
    reverse = gen_nreverse(gen_copy_seq(vars));  /* reverse the list of vars*/
 
    message_assert("no equalities, now", sc_nbre_egalites(s)==0);
 
    FOREACH(ENTITY,e,reverse)
    {
        Variable var = (Variable) e;
 
        pips_debug(5, "variable %s loop\n", entity_name((entity) var));
 
        constraints_for_bounds(var, &c, &lower, &upper);
        if( !CONTRAINTE_UNDEFINED_P(lower) && !CONTRAINTE_UNDEFINED_P(upper) )
        {
 
            if (bounds_equal_p(var, lower, upper))
            {
                /*   VAR = LOWER
                 *   body
                 */
                assign = 
                    make_assign_statement(entity_to_expression((entity) var),
                            constraints_to_loop_bound(lower, var, 
                                true, divide));
                current = 
                    make_block_statement(CONS(STATEMENT, assign,
                                CONS(STATEMENT, current,
                                    NIL)));
 
            }
            else
            {
                /*   DO VAR = LOWER, UPPER, 1
                 *     body
                 *   ENDDO
                 */
                rg = make_range(constraints_to_loop_bound(lower, var, 
                            true, divide),
                        constraints_to_loop_bound(upper, var, 
                            false, divide),
                        int_to_expression(1));
 
                current = 
                    instruction_to_statement
                    (make_instruction
                     (is_instruction_loop,
                      make_loop((entity) var,
                          rg, 
                          current,
                          entity_empty_label(),
                          make_execution(is_execution_sequential, UU),
                          NIL)));
            }
 
            contraintes_free(lower);
            contraintes_free(upper);
        }
    }
 
    gen_free_list(reverse);
    sc_inegalites(s)=c, sc_rm(s);
 
    return current;
}

References bounds_equal_p(), CONS, constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED_P, contraintes_free(), current, divide, ENDP, ENTITY, entity_empty_label(), entity_name, entity_to_expression(), FOREACH, gen_copy_seq(), gen_free_list(), gen_nreverse(), instruction_to_statement(), int_to_expression(), is_execution_sequential, is_instruction_loop, make_assign_statement(), make_block_statement(), make_execution(), make_instruction(), make_loop(), make_range(), message_assert, NIL, pips_debug, sc_dup(), sc_rm(), sc_transform_eg_in_ineg(), STATEMENT, and UU.

Referenced by broadcast(), copy_write_statement_with_cumulated_regions(), elements_loop(), generate_io_statements_for_shared_arrays(), GENERATION(), initialize_array_variable(), make_array_communication_statement(), processor_loop(), Psysteme_to_loop_nest(), and verify_array_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_change_base()

Pvecteur vect_change_base	(	Pvecteur	,
		Pbase	,
		Pvecteur	[]
	)