build-system.c File Reference

#include "defines-local.h"
#include "prettyprint.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"

Include dependency graph for build-system.c:

Go to the source code of this file.

Macros
#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"
#define	is_entity_array   0
	tags with a newgen look and feel More...
#define	is_entity_template   1
#define	is_entity_processors   2
#define	PRIME_LETTER_FOR_VARIABLES   "p"
#define	GET_DUMMY_VARIABLE_ENTITY(MODULE, NAME, lname)
	define to build the _dummy and _prime of a variable. More...
#define	STORE(name)    put_dummy_and_prime(get_ith_##name##_dummy, get_ith_##name##_prime)
#define	Psysteme_undefined   SC_UNDEFINED
	already computed constraints More...
#define	Psysteme_undefined_p(sc)   SC_UNDEFINED_P(sc)

Functions
bool	entity_hpfc_dummy_p (entity e)
	Variables. More...
static void	put_dummy_and_prime (entity(*gen1)(), gen2)
	shift dummy variables to prime variables. More...
void	hpfc_init_dummy_to_prime ()
void	hpfc_close_dummy_to_prime ()
Psysteme	shift_system_to_prime_variables (Psysteme s)
void	make_hpfc_current_mappings ()
	??? used with a temporary hack to differentiate array and templates More...
void	free_hpfc_current_mappings ()
Psysteme	compute_entity_to_declaration_constraints (entity ent, string suffix, string prefix)
	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. More...
static Psysteme	hpfc_compute_entity_to_declaration_constraints (entity e, tag what)
Psysteme	entity_to_declaration_constraints (entity e, tag what)
	gives back the constraints due to the declarations. More...
static Psysteme	hpfc_compute_align_constraints (entity e)
	Psysteme hpfc_compute_align_constraints(e) entity e is an array. More...
Psysteme	hpfc_compute_unicity_constraints (entity e)
	Psysteme hpfc_compute_unicity_constraints(e) entity e should be an array;. More...
static Psysteme	hpfc_compute_distribute_constraints (entity e)
	Psysteme hpfc_compute_distribute_constraints(e) entity e should be a template;. More...
Psysteme	entity_to_hpf_align_constraints (entity e)
Psysteme	entity_to_hpf_distribute_constraints (entity e)
effect	entity_to_region (statement stat, entity ent, tag act)
	effect entity_to_region(stat, ent, act) statement stat; entity ent; tag act; More...
Psysteme	hpfc_compute_entity_to_new_declaration (entity array)
Psysteme	entity_to_new_declaration (entity array)
Psysteme	generate_system_for_equal_variables (int n, entity(*gen1)(int), entity(*gen2)(int))
Psysteme	hpfc_unstutter_dummies (entity array)
Psysteme	generate_system_for_distributed_variable (entity v)
	Psysteme generate_system_for_variable(v) entity v;. More...

Macro Definition Documentation

ALPHA_PREFIX

#define ALPHA_PREFIX   "ALPHA"

Definition at line 42 of file build-system.c.

DELTA_PREFIX

#define DELTA_PREFIX   "DELTA"

Definition at line 47 of file build-system.c.

GAMMA_PREFIX

#define GAMMA_PREFIX   "GAMMA"

Definition at line 46 of file build-system.c.

GET_DUMMY_VARIABLE_ENTITY

#define GET_DUMMY_VARIABLE_ENTITY	(		MODULE,
			NAME,
			lname
	)

Value:

  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);   \
  }

define to build the _dummy and _prime of a variable.

Definition at line 118 of file build-system.c.

IOTA_PREFIX

#define IOTA_PREFIX   "IOTA"

Definition at line 48 of file build-system.c.

is_entity_array

#define is_entity_array   0

tags with a newgen look and feel

Definition at line 53 of file build-system.c.

is_entity_processors

#define is_entity_processors   2

Definition at line 55 of file build-system.c.

is_entity_template

#define is_entity_template   1

Definition at line 54 of file build-system.c.

LALPHA_PREFIX

#define LALPHA_PREFIX   "LALPHA"

Definition at line 43 of file build-system.c.

PRIME_LETTER_FOR_VARIABLES

#define PRIME_LETTER_FOR_VARIABLES   "p"

Definition at line 114 of file build-system.c.

PSI_PREFIX

#define PSI_PREFIX   "PSI"

Definition at line 45 of file build-system.c.

Psysteme_undefined

#define Psysteme_undefined   SC_UNDEFINED

already computed constraints

Definition at line 183 of file build-system.c.

Psysteme_undefined_p

#define Psysteme_undefined_p

(

sc

)

SC_UNDEFINED_P(sc)

Definition at line 184 of file build-system.c.

SIGMA_PREFIX

#define SIGMA_PREFIX   "SIGMA"

Definition at line 49 of file build-system.c.

STORE

#define STORE

(

name

)

put_dummy_and_prime(get_ith_##name##_dummy, get_ith_##name##_prime)

Definition at line 152 of file build-system.c.

THETA_PREFIX

#define THETA_PREFIX   "THETA"

Definition at line 44 of file build-system.c.

TMP_PREFIX

#define TMP_PREFIX   "TMP"

Definition at line 50 of file build-system.c.

Function Documentation

compute_entity_to_declaration_constraints()

Psysteme compute_entity_to_declaration_constraints	(	entity	ent,
		string	suffix,
		string	prefix
	)

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.

---

DECLARATION CONSTRAINTS GENERATION

computes the constraints due to the declarations. ! usefull

system may be empty for scalars ???

now the dummy is to be used to generate two inequalities: -dummy + lower <= 0 and dummy - upper <= 0

Parameters

ent	nt
suffix	uffix
prefix	refix

Definition at line 220 of file build-system.c.

{
    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;
}

References contrainte_make(), DIMENSION, dimension_lower, dimension_upper, entity_name, entity_type, entity_variable_p, get_ith_dummy(), hpfc_integer_constant_expression_p(), int_to_value, MAP, pips_assert, pips_debug, prefix, sc_add_inegalite(), sc_creer_base(), sc_new(), TCST, type_variable, VALUE_MONE, VALUE_ONE, variable_dimensions, vect_make(), and VECTEUR_NUL.

Referenced by hpfc_compute_entity_to_declaration_constraints().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_hpfc_dummy_p()

bool entity_hpfc_dummy_p

(

entity

e

)

Variables.

build-system.c

• 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

Definition at line 106 of file build-system.c.

{
  return same_string_p(entity_module_name(e), HPFC_PACKAGE);
}

References entity_module_name(), HPFC_PACKAGE, and same_string_p.

Referenced by put_variables_in_ordered_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_declaration_constraints()

Psysteme entity_to_declaration_constraints	(	entity	e,
		tag	what
	)

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.

Parameters

what

hat

Definition at line 285 of file build-system.c.

{
    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;
}

References concatenate(), DEBUG_SYST, entity_name, entity_variable_p, hpfc_compute_entity_to_declaration_constraints(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_shared_io_system(), generate_system_for_distributed_variable(), GENERATION(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_hpf_align_constraints()

Psysteme entity_to_hpf_align_constraints

(

entity

e

)

Definition at line 480 of file build-system.c.

{
    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;
}

References array_distributed_p(), hpfc_compute_align_constraints(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_system_for_distributed_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_hpf_distribute_constraints()

Psysteme entity_to_hpf_distribute_constraints

(

entity

e

)

Definition at line 495 of file build-system.c.

{
    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;
}

References entity_template_p(), hpfc_compute_distribute_constraints(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_system_for_distributed_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_new_declaration()

Psysteme entity_to_new_declaration

(

entity

array

)

Parameters

array

rray

Definition at line 732 of file build-system.c.

{
    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;
}

References array, array_distributed_p(), hpfc_compute_entity_to_new_declaration(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_system_for_distributed_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_region()

effect entity_to_region	(	statement	stat,
		entity	ent,
		tag	act
	)

effect entity_to_region(stat, ent, act) statement stat; entity ent; tag act;

gives the region of ent with action act in statement stat.

Parameters

stat	tat
ent	nt
act	ct

Definition at line 515 of file build-system.c.

{
    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);
}

References action_tag, EFFECT, effect_action, effect_any_reference, effect_undefined, load_statement_local_regions(), MAP, and reference_variable.

Referenced by generate_distributed_io_system(), and generate_shared_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

free_hpfc_current_mappings()

void free_hpfc_current_mappings

(

void

)

Definition at line 200 of file build-system.c.

{
    free_declaration_constraints_map();
    free_hpf_align_constraints_map();
    free_hpf_distribute_constraints_map();
    free_new_declaration_constraints_map();
}

Referenced by reset_resources_for_module().

Here is the caller graph for this function:

generate_system_for_distributed_variable()

Psysteme generate_system_for_distributed_variable

(

entity

v

)

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:

Definition at line 789 of file build-system.c.

{
    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);
}

References align_template, array_distributed_p(), base_rm, distribute_processors, entity_to_declaration_constraints(), entity_to_hpf_align_constraints(), entity_to_hpf_distribute_constraints(), entity_to_new_declaration(), load_hpf_alignment(), load_hpf_distribution(), pips_assert, sc_append(), sc_creer_base(), and sc_rn().

Referenced by generate_distributed_io_system(), and generate_remapping_system().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_system_for_equal_variables()

Psysteme generate_system_for_equal_variables	(	int	n,
		entity(*)(int)	gen1,
		entity(*)(int)	gen2
	)

Definition at line 751 of file build-system.c.

{
    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;
}

References contrainte_make(), sc_add_egalite(), sc_creer_base(), sc_rn(), TCST, VALUE_MONE, VALUE_ONE, VALUE_ZERO, vect_make(), and VECTEUR_NUL.

Referenced by generate_remapping_system(), and hpfc_unstutter_dummies().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_close_dummy_to_prime()

void hpfc_close_dummy_to_prime

(

void

)

Definition at line 168 of file build-system.c.

{
    close_dummy_to_prime();
}

Referenced by compile_module().

Here is the caller graph for this function:

hpfc_compute_align_constraints()

static Psysteme hpfc_compute_align_constraints ( entity  e )

static

Psysteme hpfc_compute_align_constraints(e) entity e is an array.

compute the align equations:

theta_i - a phi_j - b == 0

Definition at line 310 of file build-system.c.

{
    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);
}

References align_alignment, align_template, alignment_arraydim, alignment_constant, alignment_rate, alignment_undefined, array_distributed_p(), contrainte_make(), FindAlignmentOfTemplateDim(), get_ith_array_dummy(), get_ith_template_dummy(), HpfcExpressionToInt(), int_to_value, load_hpf_alignment(), NumberOfDimension(), pips_assert, sc_add_egalite(), sc_creer_base(), sc_new(), TCST, VALUE_ONE, VALUE_ZERO, vect_make(), and VECTEUR_NUL.

Referenced by entity_to_hpf_align_constraints().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_compute_distribute_constraints()

static Psysteme hpfc_compute_distribute_constraints ( entity  e )

static

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

-delta_j <= 0

delta_j - (N_j - 1) <= 0

theta_i - Nj psi_j - Nj Pj gamma_j - delta_j + Nj psi_j0 - theta_i0 == 0

if block distributed gamma_j == 0

if cyclic(1) distributed delta_j == 0

Definition at line 407 of file build-system.c.

{
    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);
}

References contrainte_make(), dimension_lower, distribute_distribution, distribute_processors, distribution_parameter, distribution_style, entity_ith_dimension(), entity_template_p(), FindDistributionOfProcessorDim(), get_ith_block_dummy(), get_ith_cycle_dummy(), get_ith_processor_dummy(), get_ith_template_dummy(), HpfcExpressionToInt(), int_to_value, load_hpf_distribution(), NumberOfDimension(), pips_assert, sc_add_egalite(), sc_add_inegalite(), sc_creer_base(), sc_new(), SizeOfIthDimension(), style_block_p, style_cyclic_p, TCST, VALUE_MONE, VALUE_ONE, vect_make(), vect_new(), VECTEUR_NUL, and VECTEUR_UNDEFINED.

Referenced by entity_to_hpf_distribute_constraints().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_compute_entity_to_declaration_constraints()

static Psysteme hpfc_compute_entity_to_declaration_constraints ( entity  e, tag  what  )

static

Definition at line 268 of file build-system.c.

{
    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);
}

References ALPHA_PREFIX, compute_entity_to_declaration_constraints(), HPFC_PACKAGE, is_entity_array, is_entity_processors, is_entity_template, PSI_PREFIX, and THETA_PREFIX.

Referenced by entity_to_declaration_constraints().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_compute_entity_to_new_declaration()

Psysteme hpfc_compute_entity_to_new_declaration

(

entity

array

)

LALPHAi == ALPHAi

LALPHAi = ALPHAi - ALPHAi_min + 1

(|a|==1) LALPHA_i == DELTA_j + 1 generalized to: (|a|!=1) |a| * (LALPHA_i - 1) + IOTA_j == DELTA_j 0 <= IOTA_j < |a|

IOTA is not needed

LALPHA_i == N* (GAMMA_j - GAMMA_0) + DELTA_j + 1

LALPHA_i = iceil(N,|a|) * (GAMMA_j - GAMMA_0) + SIGMA_j +1 DELTA_j = |a|*SIGMA_j + IOTA_j 0 <= IOTA_j < |a|

Parameters

array

rray

Definition at line 533 of file build-system.c.

{
    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;
}

References abs, array, array_distributed_p(), array_to_template, contrainte_make(), entity_undefined, get_alignment(), get_distribution(), get_entity_dimensions(), get_ith_array_dummy(), get_ith_auxiliary_dummy(), get_ith_block_dummy(), get_ith_cycle_dummy(), get_ith_dim_new_declaration(), get_ith_local_dummy(), get_ith_shift_dummy(), iceil, int_to_value, is_hpf_newdecl_alpha, is_hpf_newdecl_beta, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, is_hpf_newdecl_none, max, min, new_declaration_tag(), NumberOfDimension(), pips_assert, pips_internal_error, sc_add_egalite(), sc_add_inegalite(), sc_creer_base(), sc_rn(), TCST, template_to_processors, VALUE_MONE, VALUE_ONE, VALUE_ZERO, vect_make(), vect_new(), and VECTEUR_NUL.

Referenced by entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_compute_unicity_constraints()

Psysteme hpfc_compute_unicity_constraints

(

entity

e

)

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

Definition at line 360 of file build-system.c.

{
    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);
}

References align_alignment, align_template, alignment_undefined, array_distributed_p(), contrainte_make(), dimension_lower, entity_ith_dimension(), FindAlignmentOfTemplateDim(), get_ith_template_dummy(), HpfcExpressionToInt(), int_to_value, load_hpf_alignment(), NumberOfDimension(), pips_assert, sc_add_egalite(), sc_creer_base(), sc_new(), TCST, VALUE_ONE, vect_make(), and VECTEUR_NUL.

Referenced by generate_distributed_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_init_dummy_to_prime()

void hpfc_init_dummy_to_prime

(

void

)

Definition at line 155 of file build-system.c.

{
    init_dummy_to_prime();
    STORE(array);
    STORE(template);
    STORE(processor);
    STORE(block);
    STORE(cycle);
    STORE(local);
    STORE(shift);
    STORE(auxiliary);
}

References array, and STORE.

Referenced by compile_module().

Here is the caller graph for this function:

hpfc_unstutter_dummies()

Psysteme hpfc_unstutter_dummies

(

entity

array

)

Parameters

array

rray

Definition at line 767 of file build-system.c.

{
    int ndim = variable_entity_dimension(array);
 
    return generate_system_for_equal_variables
           (ndim, get_ith_region_dummy, get_ith_array_dummy);
}

References array, generate_system_for_equal_variables(), get_ith_array_dummy(), get_ith_region_dummy(), and variable_entity_dimension().

Referenced by generate_distributed_io_system(), and generate_shared_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

make_hpfc_current_mappings()

void make_hpfc_current_mappings

(

void

)

??? used with a temporary hack to differentiate array and templates

Definition at line 192 of file build-system.c.

{
    make_declaration_constraints_map();
    make_hpf_align_constraints_map();
    make_hpf_distribute_constraints_map();
    make_new_declaration_constraints_map();
}

Referenced by set_resources_for_module().

Here is the caller graph for this function:

put_dummy_and_prime()

static void put_dummy_and_prime ( entity (*)()  gen1, gen2    )

static

shift dummy variables to prime variables.

systeme s is modified.

Definition at line 144 of file build-system.c.

{
  int i;
  for(i=7; i>0; i--)
    store_dummy_to_prime(gen1(i), gen2(i));
}

shift_system_to_prime_variables()

Psysteme shift_system_to_prime_variables

(

Psysteme

s

)

Definition at line 173 of file build-system.c.

{
    return sc_rename_variables(s, (bool (*)())bound_dummy_to_prime_p,
                               (Variable(*)()) load_dummy_to_prime);
}

References sc_rename_variables().

Referenced by generate_remapping_system(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function: