loop_iteration_domaine_to_sc.c

Go to the documentation of this file.

/*
 
  $Id: loop_iteration_domaine_to_sc.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
 /* package conversion
  */
#include <stdio.h>
 
#include "linear.h"
 
#include "genC.h"
#include "ri.h"
#include "ri-util.h"
#include "misc.h"
 
#include "conversion.h"
 
/* 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
 */
 
Psysteme loop_iteration_domaine_to_sc(list lls,
                                      Pbase *baseindex)
{
    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;
}
 
void loop_index_domaine_to_contrainte(r, ind, sc)
range r;
entity ind;
Psysteme sc;
{
    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();
}