system_to_code.c File Reference

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "effects.h"
#include "misc.h"
#include "ri-util.h"
#include "effects-util.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "properties.h"
#include "conversion.h"

Include dependency graph for system_to_code.c:

Go to the source code of this file.

Functions
expression	Psysteme_to_expression (Psysteme systeme)
	Standard includes. More...
list	Pcontrainte_to_expression_list (Pcontrainte constraint, entity operator)
static bool	vect_simple_definition_p (Pvecteur v, Variable *pvar, Value *pcoe, Value *pcst)
	here I store simple bounds on variables appearing in the systems to allow the code generation phase to use them to improve the code. More...
static void	store_an_upper (entity var, int val)
static void	store_a_lower (entity var, int val)
void	set_information_for_code_optimizations (Psysteme s)
	I could keep the system for further optimizations... More...
void	reset_information_for_code_optimizations ()
static bool	range_of_variable (Variable var, Value *lb, Value *ub)
	this functions returns bounds for variable var if both are available. More...
static Value	vecteur_lower_bound (Pvecteur v)
	returns v lower bound if found, or INT_MIN. More...
static bool	evaluate_divide_if_possible (Pvecteur v, Value denominator, Value *result)
expression	constraints_to_loop_bound (Pcontrainte c, Variable var, bool is_lower, entity divide)
	expression constraints_to_loop_bound(c, var, is_lower) More...
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. More...
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. More...
statement	generate_optional_if (Psysteme sc, statement stat)
	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:

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:

evaluate_divide_if_possible()

static bool evaluate_divide_if_possible ( Pvecteur  v, Value  denominator, Value *  result  )

static

Definition at line 328 of file system_to_code.c.

{
    Value min=0, max=0;
 
    for(; v; v=v->succ)
    {
        Variable var = var_of(v);
        Value coef = val_of(v), lb, ub;
 
        if (var==TCST)
            value_addto(min,coef), value_addto(max,coef);
        else
        {
            Value cu,cl;
            if (!range_of_variable(var, &lb, &ub))
                return false;
            cu = value_mult(coef,ub);
            cl = value_mult(coef,lb);
            
            if (value_pos_p(coef))
                value_addto(min,cl), value_addto(max,cu);
            else
                value_addto(min,cu), value_addto(max,cl);
        }
    }
 
    value_pdivision(min, denominator);
    value_pdivision(max, denominator);
 
    *result = min;
    return value_eq(min,max);
}

References max, min, range_of_variable(), Svecteur::succ, TCST, val_of, value_addto, value_eq, value_mult, value_pdivision, value_pos_p, and var_of.

Referenced by constraints_to_loop_bound().

Here is the call graph for this function:

Here is the caller graph for this function:

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:

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

)

Standard includes.

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:

range_of_variable()

static bool range_of_variable ( Variable  var, Value *  lb, Value *  ub  )

static

this functions returns bounds for variable var if both are available.

whether bounds were found Upper Bound

no information available, that's for sure

Parameters

lb	the VARiable
ub	Lower Bound

Definition at line 264 of file system_to_code.c.

{
    if (lowers_undefined_p() || uppers_undefined_p()) 
        return false; /* no information available, that's for sure */
 
    if (!bound_lowers_p((entity) var) || !bound_uppers_p((entity) var))
        return false;
 
    *lb = int_to_value(load_lowers((entity) var));
    *ub = int_to_value(load_uppers((entity) var));
 
    return true;
}

References int_to_value.

Referenced by evaluate_divide_if_possible().

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:

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:

store_a_lower()

static void store_a_lower ( entity  var, int  val  )

static

Definition at line 189 of file system_to_code.c.

{
    pips_debug(9, "%s >= %d\n", entity_local_name(var), val);
 
    if (bound_lowers_p(var))
    {
        int old = load_lowers(var);
        if (old<val) update_lowers(var, val);
    }
    else
        store_lowers(var, val);
}

References entity_local_name(), and pips_debug.

Referenced by set_information_for_code_optimizations().

Here is the call graph for this function:

Here is the caller graph for this function:

store_an_upper()

static void store_an_upper ( entity  var, int  val  )

static

Definition at line 173 of file system_to_code.c.

{
    pips_debug(9, "%s <= %d\n", entity_local_name(var), val);
 
    if (bound_uppers_p(var))
    {
        int old = load_uppers(var);
        if (old>val) update_uppers(var, val);
    }
    else
        store_uppers(var, val);
}

References entity_local_name(), and pips_debug.

Referenced by set_information_for_code_optimizations().

Here is the call graph for this function:

Here is the caller graph for this function:

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_simple_definition_p()

static bool vect_simple_definition_p ( Pvecteur  v, Variable *  pvar, Value *  pcoe, Value *  pcst  )

static

here I store simple bounds on variables appearing in the systems to allow the code generation phase to use them to improve the code.

returns the lower and upper bounds of var if available the concept could be transfered to SC ?

size == 2

Definition at line 133 of file system_to_code.c.

{
    Variable var;
    int size = vect_size(v);
    if (size>2 || size<1) return false;
 
    var = var_of(v);
    if (var==TCST && size<=1) return false;
 
    if (var==TCST) /* size == 2 */
    {
        *pvar = var_of(v->succ);
        *pcoe = val_of(v->succ);
        *pcst = val_of(v);
        return true;
    }
    else
    {
        *pvar = var;
        *pcoe = val_of(v);
        if (!v->succ) 
        {
            *pcst = 0;
            return true;
        }
 
        if (var_of(v->succ)!=TCST) return false;
        *pcst = val_of(v->succ);
        return true;
    }
}

References Svecteur::succ, TCST, val_of, var_of, and vect_size().

Referenced by set_information_for_code_optimizations().

Here is the call graph for this function:

Here is the caller graph for this function:

vecteur_lower_bound()

static Value vecteur_lower_bound ( Pvecteur  v )

static

returns v lower bound if found, or INT_MIN.

no information available, that's for sure

val < 0, I guess

Definition at line 283 of file system_to_code.c.

{
    Value bound = 0, val;
    Variable var;
 
    if (lowers_undefined_p() || uppers_undefined_p()) 
        return VALUE_MIN; /* no information available, that's for sure */
 
    for(; v; v=v->succ)
    {
        var = var_of(v);
        val = val_of(v);
 
        if (var==TCST) 
            value_addto(bound,val) ;
        else
        {
            int il;
            Value vl,p;
            if (value_pos_p(val))
            {
                if (!bound_lowers_p((entity) var)) 
                    return VALUE_MIN;
                else
                    il = load_lowers((entity) var);
            }
            else /* val < 0, I guess */
            {
                if (!bound_uppers_p((entity) var))
                    return VALUE_MIN;
                else
                    il = load_uppers((entity) var);
            }
            
            vl = int_to_value(il);
            p = value_mult(val,vl);
            value_addto(bound,p);
        }
    }
 
    return bound;
}

References int_to_value, Svecteur::succ, TCST, val_of, value_addto, VALUE_MIN, value_mult, value_pos_p, and var_of.

Referenced by constraints_to_loop_bound().

Here is the caller graph for this function: