build-system.c

Go to the documentation of this file.

/*
 
  $Id: build-system.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
/*
 * build-system.c
 *
 * here should be build equations and inequations to deal
 * with the I/O in hpf programs.
 *
 * Fabien COELHO, Feb/Mar 94
 */
 
#include "defines-local.h"
#include "prettyprint.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
 
#define ALPHA_PREFIX    "ALPHA"
#define LALPHA_PREFIX   "LALPHA"
#define THETA_PREFIX    "THETA"
#define PSI_PREFIX      "PSI"
#define GAMMA_PREFIX    "GAMMA"
#define DELTA_PREFIX    "DELTA"
#define IOTA_PREFIX     "IOTA"
#define SIGMA_PREFIX    "SIGMA"
#define TMP_PREFIX      "TMP"
 
/* tags with a newgen look and feel */
#define is_entity_array         0
#define is_entity_template      1
#define is_entity_processors    2
 
/* Variables
 *  + array dimensions (PHIs)
 *  + template dimensions
 *  + processor dimensions
 *  + cycles and offsets
 *  + local array dimensions
 *  + indexes and others coming thru the regions
 *
 * Inequations to be defined
 *  + array declaration
 *  + template declaration
 *  + processors arrangement declaration
 *  + local offsets within a block
 *  + local declarations
 *  - regions accessed by the statement
 *
 * Equations to be defined
 *  + alignement
 *  + distribution
 *  + local <-> global?
 *  + processor linearization?
 *
 * Remarks
 *  - offset to be computed
 *  - access functions are not needed (hidden by regions)
 *  - how to be sure that something can be done?
 *  - will newgen structures be necessary to build the systems?
 *  - will I have to remove some variables (indexes ?)
 *  - one equation to be added for replicated dimensions.
 */
 
/* variable names:
 *
 * ALPHA{1-7}: array dimensions, 
 * THETA{1-7}: template dimensions,
 * PSI{1-7}: processor dimensions,
 * SIGMA{1-7}: auxiliary variable,
 * GAMMA{1-7}: cycles,
 * DELTA{1-7}: local offsets,
 * LALPHA{1-7}: local array dimensions, if specified...
 *
 * plus "PRIME" versions
 */
 
/* ------------------------------------------------------------------
 *
 * HPF CONSTRAINTS GENERATION
 */
 
bool entity_hpfc_dummy_p(e)
entity e;
{
  return same_string_p(entity_module_name(e), HPFC_PACKAGE);
}
 
/********************************************************* DUMMY VARIABLES */
 
#define PRIME_LETTER_FOR_VARIABLES      "p"
 
/* define to build the _dummy and _prime of a variable.
 */
#define GET_DUMMY_VARIABLE_ENTITY(MODULE, NAME, lname)                  \
  entity get_ith_##lname##_dummy(int i)                                 \
  {                                                                     \
    return get_ith_dummy(MODULE, NAME, i);                              \
  }                                                                     \
  entity get_ith_##lname##_prime(int i)                                 \
  {                                                                     \
    return get_ith_dummy(MODULE, NAME PRIME_LETTER_FOR_VARIABLES, i);   \
  }
 
GET_DUMMY_VARIABLE_ENTITY(REGIONS_MODULE_NAME,  PHI_PREFIX,     region)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         ALPHA_PREFIX,   array)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         THETA_PREFIX,   template)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         PSI_PREFIX,     processor)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         DELTA_PREFIX,   block)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         GAMMA_PREFIX,   cycle)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         LALPHA_PREFIX,  local)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         IOTA_PREFIX,    shift)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         SIGMA_PREFIX,   auxiliary)
GET_DUMMY_VARIABLE_ENTITY(HPFC_PACKAGE,         TMP_PREFIX,     temporary)
 
/* shift dummy variables to prime variables.
 * systeme s is modified.
 */
GENERIC_LOCAL_FUNCTION(dummy_to_prime, entitymap)
 
static void put_dummy_and_prime(gen1, gen2)
entity (*gen1)(), (*gen2)();
{
  int i;
  for(i=7; i>0; i--)
    store_dummy_to_prime(gen1(i), gen2(i));
}
 
#define STORE(name) \
  put_dummy_and_prime(get_ith_##name##_dummy, get_ith_##name##_prime)
 
void hpfc_init_dummy_to_prime()
{
    init_dummy_to_prime();
    STORE(array);
    STORE(template);
    STORE(processor);
    STORE(block);
    STORE(cycle);
    STORE(local);
    STORE(shift);
    STORE(auxiliary);
}
 
void hpfc_close_dummy_to_prime()
{
    close_dummy_to_prime();
}
 
Psysteme shift_system_to_prime_variables(s)
Psysteme s;
{
    return sc_rename_variables(s, (bool (*)())bound_dummy_to_prime_p,
                               (Variable(*)()) load_dummy_to_prime);
}
 
/* already computed constraints
 */
#ifndef Psysteme_undefined
#define Psysteme_undefined SC_UNDEFINED
#define Psysteme_undefined_p(sc) SC_UNDEFINED_P(sc)
#endif
/* ??? used with a temporary hack to differentiate array and templates */
GENERIC_LOCAL_MAPPING(declaration_constraints, Psysteme, entity)
GENERIC_LOCAL_MAPPING(hpf_align_constraints, Psysteme, entity)
GENERIC_LOCAL_MAPPING(hpf_distribute_constraints, Psysteme, entity)
GENERIC_LOCAL_MAPPING(new_declaration_constraints, Psysteme, entity)
 
void make_hpfc_current_mappings()
{
    make_declaration_constraints_map();
    make_hpf_align_constraints_map();
    make_hpf_distribute_constraints_map();
    make_new_declaration_constraints_map();
}
 
void free_hpfc_current_mappings()
{
    free_declaration_constraints_map();
    free_hpf_align_constraints_map();
    free_hpf_distribute_constraints_map();
    free_new_declaration_constraints_map();
}
 
/* ------------------------------------------------------------------
 *
 * DECLARATION CONSTRAINTS GENERATION
 */
 
/* Psysteme compute_entity_to_constraints(ent, suffix, prefix)
 * entity ent: variable the constraints of which are computed
 * strings suffix and prefix: to be used in the dummy variables created
 *
 * computes the constraints due to the declarations.
 *! usefull
 */
Psysteme compute_entity_to_declaration_constraints(ent, suffix, prefix)
entity ent;
string suffix, prefix;
{
    list dims = variable_dimensions(type_variable(entity_type(ent)));
    int dim_number = 1;
    Psysteme new_system = sc_new();
    
    pips_assert("variable", entity_variable_p(ent));
    
    /* system may be empty for scalars ???
     */
    pips_debug(5, "entity %s, [%s,%s]\n", entity_name(ent), prefix, suffix);
    
    MAP(DIMENSION, dim,
     {
         entity dummy = get_ith_dummy(prefix, suffix, dim_number);
         int ilower;
         int iupper;
         bool blower = hpfc_integer_constant_expression_p
             (dimension_lower(dim), &ilower);
         bool bupper = hpfc_integer_constant_expression_p
             (dimension_upper(dim), &iupper);
 
         pips_assert("extent known", blower && bupper);
         
         /* now the dummy is to be used to generate two inequalities: 
          * -dummy + lower <= 0 and dummy - upper <= 0
          */
         sc_add_inegalite
             (new_system,
              contrainte_make(vect_make(VECTEUR_NUL,
                                        dummy,  VALUE_MONE,
                                        TCST,   int_to_value(ilower))));
         sc_add_inegalite
             (new_system,
              contrainte_make(vect_make(VECTEUR_NUL,
                                        dummy,  VALUE_ONE,
                                        TCST,   int_to_value(-iupper))));
         dim_number++;
     },
         dims);
    
    sc_creer_base(new_system);
    return new_system;
}
 
static Psysteme 
hpfc_compute_entity_to_declaration_constraints(
    entity e,
    tag what)
{
    string local_prefix = (what==is_entity_array? ALPHA_PREFIX:
                           what==is_entity_template? THETA_PREFIX:
                           what==is_entity_processors? PSI_PREFIX: "ERROR");
 
    return compute_entity_to_declaration_constraints
           (e, local_prefix, HPFC_PACKAGE);
}
 
/* gives back the constraints due to the declarations.
 * Uses a demand driven approach: computed systems are stored
 * in the declaration_constraints mapping for later search.
 */
Psysteme 
entity_to_declaration_constraints(
    entity e,
    tag what)
{
    Psysteme p = load_entity_declaration_constraints(e+what);
    pips_assert("variable", entity_variable_p(e));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_entity_to_declaration_constraints(e, what);
        store_entity_declaration_constraints(e+what, p);
    }
 
    DEBUG_SYST(9, concatenate("entity ", entity_name(e), NULL), p);
 
    return p;
}
 
/* Psysteme hpfc_compute_align_constraints(e)
 * entity e is an array
 *
 * compute the align equations:
 *
 * theta_i - a phi_j - b == 0
 */
static Psysteme hpfc_compute_align_constraints(e)
entity e;
{
    align al = load_hpf_alignment(e);
    entity template = align_template(al);
    Psysteme new_system = sc_new();
    int i;
 
    pips_assert("distributed array", array_distributed_p(e));
 
    for(i=1 ; i<=NumberOfDimension(template) ; i++)
    {
        entity theta = get_ith_template_dummy(i);
        alignment a = FindAlignmentOfTemplateDim(align_alignment(al), i);
        
        if (a!=alignment_undefined)
        {
            int adim = alignment_arraydim(a),
                constant = HpfcExpressionToInt(alignment_constant(a));
            Pvecteur
                v = vect_make(VECTEUR_NUL,
                              theta,    VALUE_ONE,
                              TCST,     int_to_value(-constant));
                                               
            if (adim==0)
            {
                sc_add_egalite(new_system, contrainte_make(v));
            }
            else
            {
                entity phi = get_ith_array_dummy(adim);
                int rate = HpfcExpressionToInt(alignment_rate(a));
 
                v = vect_make(v, phi, int_to_value(-rate), TCST, VALUE_ZERO);
                sc_add_egalite(new_system, contrainte_make(v));
            }
        }
    }
 
    sc_creer_base(new_system);
    return(new_system);
}
 
/* Psysteme hpfc_compute_unicity_constraints(e)
 * entity e should be an array;
 *
 * equations for non aligned template dimensions are computed: ???
 *
 * theta_i - lower_template_i == 0
 */
Psysteme hpfc_compute_unicity_constraints(e)
entity e;
{
    align al = load_hpf_alignment(e);
    entity template = align_template(al);
    Psysteme new_system = sc_new();
    int i;
 
    pips_assert("distributed array", array_distributed_p(e));
 
    for(i=1 ; i<=NumberOfDimension(template) ; i++)
    {
        alignment
            a = FindAlignmentOfTemplateDim(align_alignment(al), i);
        
        if (a==alignment_undefined)
        {
            entity
                theta = get_ith_template_dummy(i);
            int
                low = 
                    HpfcExpressionToInt
                        (dimension_lower(entity_ith_dimension(template, i)));
 
            sc_add_egalite
                (new_system,
                 contrainte_make(vect_make(VECTEUR_NUL,
                                           theta,       VALUE_ONE,
                                           TCST,        int_to_value(-low))));
        }
    }
    sc_creer_base(new_system);
    return(new_system);
}
 
/* Psysteme hpfc_compute_distribute_constraints(e)
 * entity e should be a template;
 *
 * the constraints due to the distribution are defined:
 *
 * theta_i - theta_i0 == Nj Pj gamma_j + Nj (psi_j - psi_j0) + delta_j
 * delta_j >= 0
 * delta_j < Nj
 * ??? if block distribution: gamma_j == 0 
 * ??? not distributed template dimensions are skipped...
 * ??? if cyclic(1) distribution: delta_j == 0
 */
static Psysteme hpfc_compute_distribute_constraints(e)
entity e;
{
    Psysteme new_system = sc_new();
    distribute di = load_hpf_distribution(e);
    entity proc = distribute_processors(di);
    list ld = distribute_distribution(di);
    int j, i;
    
    pips_assert("template", entity_template_p(e));
 
    for(j=1 ; j<=NumberOfDimension(proc) ; j++)
    {
        distribution
            d = FindDistributionOfProcessorDim(ld, j, &i);
        entity
            theta = get_ith_template_dummy(i),
            psi = get_ith_processor_dummy(j),
            gamma = get_ith_cycle_dummy(j),
            delta = get_ith_block_dummy(j);
        int
            param = HpfcExpressionToInt(distribution_parameter(d)),
            theta0 = HpfcExpressionToInt
                (dimension_lower(entity_ith_dimension(e, i))),
            psi0 = HpfcExpressionToInt
                (dimension_lower(entity_ith_dimension(proc, j))),
            proc_size = SizeOfIthDimension(proc, j);
        style st = distribution_style(d);
        Pvecteur v = VECTEUR_UNDEFINED;
 
        /* -delta_j <= 0
         */
        sc_add_inegalite(new_system, 
                contrainte_make(vect_new((Variable) delta, VALUE_MONE)));
 
        /* delta_j - (N_j - 1) <= 0
         */
        sc_add_inegalite(new_system,
           contrainte_make(vect_make(VECTEUR_NUL,
                                     (Variable) delta,  VALUE_ONE,
                                     TCST, int_to_value(-param+1))));
 
        /* theta_i - Nj psi_j - Nj Pj gamma_j - delta_j + Nj psi_j0 - theta_i0
         * == 0
         */
        v = vect_make(VECTEUR_NUL,
                      (Variable) theta, VALUE_ONE,
                      (Variable) psi,   int_to_value(-param),
                      (Variable) gamma, int_to_value(-(param*proc_size)),
                      (Variable) delta, VALUE_MONE,
                      TCST,             int_to_value((param*psi0)-theta0));
 
        sc_add_egalite(new_system, contrainte_make(v)); 
 
        /* if block distributed
         * gamma_j == 0
         */
        if (style_block_p(st))
            sc_add_egalite(new_system,
               contrainte_make(vect_new((Variable) gamma, VALUE_ONE)));
 
        /* if cyclic(1) distributed
         * delta_j == 0
         */
        if (style_cyclic_p(st) && (param==1))
            sc_add_egalite(new_system,
                contrainte_make(vect_new((Variable) delta, VALUE_ONE)));
            
    }
    sc_creer_base(new_system);
    return(new_system);
}
 
Psysteme entity_to_hpf_align_constraints(entity e)
{
    Psysteme p = load_entity_hpf_align_constraints(e);
 
    pips_assert("distributed variable", array_distributed_p(e));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_align_constraints(e);
        store_entity_hpf_align_constraints(e, p);
    }
 
    return p;
}
 
Psysteme entity_to_hpf_distribute_constraints(entity e)
{
    Psysteme p = load_entity_hpf_distribute_constraints(e);
 
    pips_assert("template", entity_template_p(e));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_distribute_constraints(e);
        store_entity_hpf_distribute_constraints(e, p);
    }
 
    return p;
}
 
/* effect entity_to_region(stat, ent, act)
 * statement stat; entity ent; tag act;
 *
 * gives the region of ent with action act in statement stat.
 */
effect entity_to_region(
    statement stat,
    entity ent,
    tag act)
{
    list l = load_statement_local_regions(stat);
 
    MAP(EFFECT, e,
        if ((reference_variable(effect_any_reference(e))==ent) &&
            ((int) action_tag(effect_action(e))==act)) return(e),
        l);
 
    return(effect_undefined);
}
 
/********************************************************* NEW DECLARATIONS */
 
Psysteme 
hpfc_compute_entity_to_new_declaration(
    entity array)
{
    int dim = NumberOfDimension(array);
    Psysteme syst = sc_rn(NULL);
 
    pips_assert("distributed array", array_distributed_p(array));
 
    for (; dim>0; dim--)
    {
         entity lalpha = get_ith_local_dummy(dim),
                alpha = get_ith_array_dummy(dim);
 
         switch (new_declaration_tag(array, dim))
         {
         case is_hpf_newdecl_none:
             /* LALPHAi == ALPHAi
              */
             sc_add_egalite
                 (syst, 
                  contrainte_make(vect_make(VECTEUR_NUL,
                                            alpha,      VALUE_ONE,
                                            lalpha,     VALUE_MONE,
                                            TCST,       VALUE_ZERO)));
             break;
         case is_hpf_newdecl_alpha:
         {
             /* LALPHAi = ALPHAi - ALPHAi_min + 1
              */
             int min = 314159;
             int max = -314159;
 
             get_ith_dim_new_declaration(array, dim, &min, &max);
             
             sc_add_egalite
                 (syst,
                  contrainte_make(vect_make(VECTEUR_NUL,
                                            alpha,      VALUE_ONE,
                                            lalpha,     VALUE_MONE,
                                            TCST,       int_to_value(1-min))));
 
             break;
         }
         case is_hpf_newdecl_beta:
         {
             /* (|a|==1) LALPHA_i == DELTA_j + 1
              * generalized to:
              * (|a|!=1) |a| * (LALPHA_i - 1) + IOTA_j == DELTA_j
              *           0 <= IOTA_j < |a|
              */
             entity delta, template = array_to_template(array);
             int tdim, pdim, a, b, n;
             
             get_alignment(array, dim, &tdim, &a, &b);
             pips_assert("aligned dimension", a!=0 && tdim!=0);
             get_distribution(template, tdim, &pdim, &n);
             
             delta = get_ith_block_dummy(pdim);
 
             if (abs(a)==1)
             {
                 /* IOTA is not needed */
                 sc_add_egalite(syst,
                   contrainte_make(vect_make(VECTEUR_NUL,
                                             delta,     VALUE_ONE,
                                             lalpha,    VALUE_MONE,
                                             TCST,      VALUE_ONE)));
             }
             else
             {
                 entity iota = get_ith_shift_dummy(pdim);
                 Pvecteur
                     v1 = vect_make(VECTEUR_NUL,
                                    (Variable) lalpha,  int_to_value(abs(a)),
                                    (Variable) iota,    VALUE_ONE,
                                    (Variable) delta,   VALUE_MONE,
                                    TCST,       int_to_value(-abs(a)));
 
                 sc_add_egalite(syst, contrainte_make(v1));
                 sc_add_inegalite(syst,
                                  contrainte_make(vect_new((Variable) iota, 
                                                           VALUE_MONE)));
                 sc_add_inegalite
                     (syst,
                      contrainte_make(vect_make(VECTEUR_NUL,
                             (Variable) iota, VALUE_ONE,
                              TCST,     int_to_value(-(abs(a)-1)))));
             }
 
             break;
         }
         case is_hpf_newdecl_gamma:
         {
             /* LALPHA_i == N* (GAMMA_j - GAMMA_0) + DELTA_j + 1
              */
             entity
                 gamma = entity_undefined,
                 delta = entity_undefined,
                 template = array_to_template(array),
                 processor = template_to_processors(template);
             int gamma_0 = 0, tdim = -1, pdim = -1, a = 0, b = 0,
                 n, plow, pup, tlow, tup, alow, aup;
             
             get_alignment(array, dim, &tdim, &a, &b);
             pips_assert("stride-1 aligned", abs(a)==1 && tdim!=0);
             
             get_distribution(template, tdim, &pdim, &n);
             pips_assert("distributed dimension", pdim>0 && n>0);
             
             get_entity_dimensions(array, dim, &alow, &aup);
             get_entity_dimensions(template, tdim, &tlow, &tup);
             get_entity_dimensions(processor, pdim, &plow, &pup);
 
             delta = get_ith_block_dummy(pdim);
             gamma = get_ith_cycle_dummy(pdim);
 
             gamma_0 = (a*alow + b - tlow) % (n * (pup - plow + 1));
 
             sc_add_egalite
                 (syst,
                  contrainte_make(vect_make
                    (VECTEUR_NUL,
                     delta,     VALUE_ONE,
                     gamma,     int_to_value(n),
                     lalpha,    VALUE_MONE,
                     TCST,      int_to_value(1-(n*gamma_0)))));
             break;
         }
         case is_hpf_newdecl_delta:
         {
             /* LALPHA_i = iceil(N,|a|) * (GAMMA_j - GAMMA_0) + SIGMA_j +1
              * DELTA_j = |a|*SIGMA_j + IOTA_j
              * 0 <= IOTA_j < |a|
              */
             entity sigma = entity_undefined,
                 iota = entity_undefined,
                 gamma = entity_undefined,
                 delta = entity_undefined,
                 template = array_to_template(array),
                 processor = template_to_processors(template);
             int gamma_0 = 0, tdim = -1, pdim = -1, a = 0, b = 0,
                 n, icn, plow, pup, tlow, tup, alow, aup;
             
             get_alignment(array, dim, &tdim, &a, &b);
             pips_assert("aligned dimension", tdim!=0);
             
             get_distribution(template, tdim, &pdim, &n);
             pips_assert("distributed dimension", pdim>0 && n>0);
             
             get_entity_dimensions(array, dim, &alow, &aup);
             get_entity_dimensions(template, tdim, &tlow, &tup);
             get_entity_dimensions(processor, pdim, &plow, &pup);
 
             sigma = get_ith_auxiliary_dummy(pdim);
             iota = get_ith_shift_dummy(pdim);
             delta = get_ith_block_dummy(pdim);
             gamma = get_ith_cycle_dummy(pdim);
 
             gamma_0 = (a*alow + b - tlow) % (n * (pup - plow + 1));
             icn = iceil(n, abs(a));
 
             sc_add_egalite
                 (syst,
                  contrainte_make
                  (vect_make(VECTEUR_NUL,
                             sigma,     VALUE_ONE,
                             gamma,     int_to_value(icn),
                             lalpha,    VALUE_MONE,
                             TCST,      int_to_value(1-(icn*gamma_0)))));
 
             sc_add_egalite
                 (syst,
                  contrainte_make
                  (vect_make(VECTEUR_NUL,
                             delta,     VALUE_ONE,
                             sigma,     int_to_value(-abs(a)),
                             iota,      VALUE_MONE,
                             TCST,      VALUE_ZERO)));
 
             sc_add_inegalite(syst,
                              contrainte_make(vect_new((Variable) iota, 
                                                       VALUE_MONE)));
             sc_add_inegalite
                 (syst,
                  contrainte_make
                  (vect_make(VECTEUR_NUL,
                             (Variable) iota, VALUE_ONE,
                             TCST,      int_to_value(-(abs(a)-1)))));
             break;
         }
         default:
             pips_internal_error("unexpected new declaration tag");
         }
     }
    
    sc_creer_base(syst);
    return syst;
}
 
Psysteme entity_to_new_declaration(array)
entity array;
{
    Psysteme p = load_entity_new_declaration_constraints(array);
 
    pips_assert("distributed array", array_distributed_p(array));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_entity_to_new_declaration(array);
        store_entity_new_declaration_constraints(array, p);
    }
 
    return p;
}
 
/*********************************** REGION and ARRAY link: PHIi == ALPHAi */
 
Psysteme 
generate_system_for_equal_variables(
    int n,
    entity (*gen1)(int),
    entity (*gen2)(int))
{
    Psysteme s = sc_rn(NULL);
 
    for(; n>0; n--)
        sc_add_egalite(s, contrainte_make
             (vect_make(VECTEUR_NUL, gen1(n), VALUE_ONE, 
                        gen2(n), VALUE_MONE, TCST, VALUE_ZERO)));
 
    sc_creer_base(s); return s;
}
 
Psysteme 
hpfc_unstutter_dummies(
    entity array)
{
    int ndim = variable_entity_dimension(array);
 
    return generate_system_for_equal_variables
           (ndim, get_ith_region_dummy, get_ith_array_dummy);
}
 
/* Psysteme generate_system_for_variable(v)
 * entity v;
 *
 * what: generates a system for DISTRIBUTED variable v.
 * how: uses the declarations of v, t, p and align and distribute, 
 *      and new declarations.
 * input: entity (variable) v
 * output: the built system, which is a new allocated system.
 * side effects:
 *  - uses many functions that build and store systems...
 * bugs or features:
 */
Psysteme 
generate_system_for_distributed_variable(
    entity v)
{
    Psysteme result = sc_rn(NULL);
    entity t, p;
 
    pips_assert("distributed array", array_distributed_p(v));
 
    t = align_template(load_hpf_alignment(v)),
    p = distribute_processors(load_hpf_distribution(t));    
 
    result = sc_append(result, entity_to_declaration_constraints(v, 0));
    result = sc_append(result, entity_to_declaration_constraints(t, 1));
    result = sc_append(result, entity_to_declaration_constraints(p, 2));
    result = sc_append(result, entity_to_hpf_align_constraints(v));
    result = sc_append(result, entity_to_hpf_distribute_constraints(t));
    result = sc_append(result, entity_to_new_declaration(v));
 
    base_rm(sc_base(result)), sc_base(result) = NULL, sc_creer_base(result);
 
    return(result);
}
 
/* that is all
 */