declarations.c File Reference

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

Include dependency graph for declarations.c:

Go to the source code of this file.

Macros
#define	STATIC_LIST_OF_HPF_OBJECTS(name, set_name, pred_name)
	in static_controlize More...
#define	normalized_dimension_p(dim)    (HpfcExpressionToInt(dimension_lower(dim))==1)
	local macros... More...

Functions
bool	expression_constant_p (expression)
	HPFC module by Fabien COELHO. More...
	STATIC_LIST_OF_HPF_OBJECTS (distributed_arrays, set_array_as_distributed, array_distributed_p)
list	list_of_distributed_arrays_for_module (entity module)
	returns the list of entities that are 'local' to module More...
void	reset_hpf_object_lists ()
void	free_hpf_object_lists ()
static void	init_currents ()
void	init_hpf_number_status ()
	STANDARS STATIC MANAGEMENT. More...
numbers_status	get_hpf_number_status ()
void	reset_hpf_number_status ()
void	set_hpf_number_status (numbers_status s)
void	close_hpf_number_status ()
void	GiveToHpfObjectsTheirNumber ()
	give to hpf objects listed in distributedarrays, templates and processors their number for the code generation... More...
expression	entity_hpf_number (entity e)
	returns the hpf_number parameter as a string not really needed ??? ??? never called More...
tag	new_declaration_tag (entity array, int dim)
static void	create_new_declaration (entity e)
static void	store_a_new_declaration (entity array, int dim, tag what)
void	get_ith_dim_new_declaration (entity array, int i, int *pmin, int *pmax)
void	init_data_status ()
data_status	get_data_status ()
void	reset_data_status ()
void	set_data_status (data_status s)
void	close_data_status ()
static void	NormalizeOneTemplateDistribution (distribution d, entity templ, int *templdimp, entity procs, int *procsdimp)
	NormalizeOneTemplateDistribution. More...
void	normalize_distribute (entity t, distribute d)
void	normalize_align (_UNUSED_ entity e, align a)
void	normalize_hpf_object (entity v)
void	NormalizeHpfDeclarations ()
static int	ComputeNewSizeOfIthDimension (dimension dim, int i, entity array, tag *newdeclp)
	here the new size of the ith dimension of the given array is computed. More...
static void	NewDeclarationOfDistributedArray (entity array)
	for node this are reformated, and for host these variables are deleted. More...
void	NewDeclarationsOfDistributedArrays ()
	this procedure generate the new declarations of every distributed arrays of the program, in order to minimize the amount of memory used. More...
static void	create_overlaps (entity e)
void	set_overlap (entity ent, int dim, int side, int width)
	set the overlap value for entity ent, on dimension dim, dans side side to width, which must be a positive integer. More...
int	get_overlap (entity ent, int dim, int side)
	returns the overlap for a given entity, dimension and side, to be used in the declaration modifications More...
static void	overlap_redefine_expression (expression *pexpr, int ov)
	redefines the bound given the overlap which is to be included More...
static void	declaration_with_overlaps (list l)
void	declaration_with_overlaps_for_module (entity module)
static void	update_overlaps_of (entity u, entity v)
void	update_overlaps_in_caller (entity fun, list le)
	the overlaps of the actual parameters are updated according to the formal requirements. More...

Variables
static int	current_array_index = 1
static int	current_template_index = 1
static int	current_processors_index = 1

Macro Definition Documentation

normalized_dimension_p

#define normalized_dimension_p

(

dim

)

(HpfcExpressionToInt(dimension_lower(dim))==1)

local macros...

Definition at line 447 of file declarations.c.

STATIC_LIST_OF_HPF_OBJECTS

#define STATIC_LIST_OF_HPF_OBJECTS	(		name,
			set_name,
			pred_name
	)

Value:

static list name = NIL;\
int number_of_##name(){return(gen_length(name));}\
list list_of_##name(){return(name);}\
bool pred_name(entity e){return(gen_in_list_p(e, name));}\
void set_name(entity e){ if (!gen_in_list_p(e, name)){\
 name = CONS(ENTITY, e, name); normalize_hpf_object(e);}}

in static_controlize

DISTRIBUTED ARRAYS

Definition at line 46 of file declarations.c.

Function Documentation

close_data_status()

void close_data_status

(

void

)

Definition at line 339 of file declarations.c.

{
    close_new_declaration();
    close_hpf_alignment();
    close_hpf_distribution();
    free_hpf_object_lists();
}

References close_hpf_alignment(), close_hpf_distribution(), and free_hpf_object_lists().

Here is the call graph for this function:

close_hpf_number_status()

void close_hpf_number_status

(

void

)

Definition at line 157 of file declarations.c.

{
    close_hpf_number();
    init_currents();
}

References close_hpf_number(), and init_currents().

Here is the call graph for this function:

ComputeNewSizeOfIthDimension()

static int ComputeNewSizeOfIthDimension ( dimension  dim, int  i, entity  array, tag *  newdeclp  )

static

here the new size of the ith dimension of the given array is computed.

because the declarations are static, there is a majoration of the space required on each processors to held his part of the distributed array.

default: the new declaration is the same as the old one.

looking for the matching alignment...

no alignment => scratching of the dimension...

there is an alignment, but the rate is zero, so the whole dimension has to be declared on every processors, despite the fact that the dimension is mapped on only one element.

looking for the matching distribution... pdim is the corresponding dimension of processors p

no style => scratching of the dimension...

??? should delete the alignment which is not usefull...

alpha case

and now, let's look at the different cases.

beta case

gamma case

??? what about rate==-1 ?

delta case

alpha case, if nothing matches, what shouldn't be the case :

Definition at line 455 of file declarations.c.

{
    align a = load_hpf_alignment(array);
    entity t = align_template(a);
    distribute d = load_hpf_distribution(t);
    alignment al = alignment_undefined;
    distribution di = distribution_undefined;
    int rate, param, pdim = 1, asize = 0;
    style st;
 
    asize=dimension_size(dim);
 
    pips_debug(9, "dimension %d of array %s\n", i, entity_name(array));
    ifdebug(9)
    {
        print_align(a);
        print_distribute(d);
    }
 
    /* default: the new declaration is the same as the old one.
     */
    (*newdeclp) = is_hpf_newdecl_none;
 
    /* looking for the matching alignment...
     */
    al = FindAlignmentOfDim(align_alignment(a), i);
 
    /* no alignment => scratching of the dimension...
     */
    if (al==alignment_undefined) 
    {
        if (!normalized_dimension_p(dim)) 
            (*newdeclp) = is_hpf_newdecl_alpha;
        return(asize);
    }
 
    /* there is an alignment, but the rate is zero, so the whole
     * dimension has to be declared on every processors, despite the
     * fact that the dimension is mapped on only one element.
     */
    rate=HpfcExpressionToInt(alignment_rate(al));
    if (rate==0) 
    {
        if (!normalized_dimension_p(dim)) 
            (*newdeclp) = is_hpf_newdecl_alpha;
        return asize;
    }
    
    /* looking for the matching distribution...
     * pdim is the corresponding dimension of  processors p
     */
    di = FindDistributionOfDim(distribute_distribution(d),
                               alignment_templatedim(al),
                               &pdim);
                               
    st=distribution_style(di);
 
    /* no style => scratching of the dimension...
     */
    if (style_none_p(st)) 
    {
        /* ???
         * should delete the alignment which is not usefull...
         */
        /* alpha case
         */
        if (!normalized_dimension_p(dim)) 
            (*newdeclp) = is_hpf_newdecl_alpha;
        return asize;
    }
    
    /* and now, let's look at the different cases.
     *
     * beta case
     */
    param=HpfcExpressionToInt(distribution_parameter(di));
 
    if (style_block_p(st))
    {
        int
            major = iceil(param, abs(rate)),
            choice = min(asize, major);
 
        if (choice==asize)
        {
            if (normalized_dimension_p(dim)) 
                (*newdeclp) = is_hpf_newdecl_none;
            else
                (*newdeclp) = is_hpf_newdecl_alpha;
        }
        else
            (*newdeclp) = is_hpf_newdecl_beta;
 
        return choice;
    }
 
    /* gamma case
     *
     * ??? what about rate==-1 ?
     */
    if (style_cyclic_p(st) && (rate==1))
    {
        int
            psize = SizeOfIthDimension(distribute_processors(d), pdim),
            major = param * iceil(asize+param-1, param*psize),
            choice = min(asize, major);
 
        if (choice==asize)
        {
            if (normalized_dimension_p(dim)) 
                (*newdeclp) = is_hpf_newdecl_none;
            else
                (*newdeclp) = is_hpf_newdecl_alpha;
        }
        else
            (*newdeclp) = is_hpf_newdecl_gamma;
 
        return choice;
    }
 
    /* delta case
     */
    if (style_cyclic_p(st))
    {
        int
            absrate = abs(rate),
            psize = SizeOfIthDimension(distribute_processors(d),pdim),
            major = (iceil(param, absrate)*
                     iceil(absrate*(asize-1)+param, param*psize)),
            choice = min(asize, major);
 
        if (choice==asize)
        {
            if (normalized_dimension_p(dim)) 
                (*newdeclp) = is_hpf_newdecl_none;
            else
                (*newdeclp) = is_hpf_newdecl_alpha;
        }
        else
            (*newdeclp) = is_hpf_newdecl_delta;
 
        return choice;
    }
        
    /* alpha case, if nothing matches, what shouldn't be the case :
     */
    if (!normalized_dimension_p(dim)) 
        (*newdeclp) = is_hpf_newdecl_alpha;
    return asize;
}

References abs, align_alignment, align_template, alignment_rate, alignment_templatedim, alignment_undefined, array, choice, dimension_size(), distribute_distribution, distribute_processors, distribution_parameter, distribution_style, distribution_undefined, entity_name, FindAlignmentOfDim(), FindDistributionOfDim(), HpfcExpressionToInt(), iceil, ifdebug, is_hpf_newdecl_alpha, is_hpf_newdecl_beta, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, is_hpf_newdecl_none, load_hpf_alignment(), load_hpf_distribution(), min, normalized_dimension_p, pips_debug, print_align(), print_distribute(), SizeOfIthDimension(), style_block_p, style_cyclic_p, and style_none_p.

Referenced by NewDeclarationOfDistributedArray().

Here is the call graph for this function:

Here is the caller graph for this function:

create_new_declaration()

static void create_new_declaration ( entity  e )

static

Definition at line 248 of file declarations.c.

{
    type t = entity_type(e);
    list l = NIL;
    int ndim;
 
    pips_assert("variable", type_variable_p(t));
    
    ndim = gen_length(variable_dimensions(type_variable(t)));
 
    for(; ndim>0; ndim--)
        l = CONS(HPF_NEWDECL, make_hpf_newdecl(is_hpf_newdecl_none, UU), l);
 
    store_new_declaration(e, make_hpf_newdecls(l));
}

References CONS, entity_type, gen_length(), HPF_NEWDECL, is_hpf_newdecl_none, make_hpf_newdecl(), make_hpf_newdecls(), NIL, pips_assert, type_variable, type_variable_p, UU, and variable_dimensions.

Referenced by store_a_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

create_overlaps()

static void create_overlaps ( entity  e )

static

Definition at line 693 of file declarations.c.

{
    type t = entity_type(e);
    list o=NIL;
    int n;
 
    pips_assert("variable", type_variable_p(t));
 
    n = gen_length(variable_dimensions(type_variable(t)));
    for(; n>=1; n--) o = CONS(OVERLAP, make_overlap(0, 0), o);
 
    store_overlap_status(e, o);
 
    pips_assert("overlap stored", bound_overlap_status_p(e));
}

References bound_overlap_status_p(), CONS, entity_type, gen_length(), make_overlap(), NIL, OVERLAP, pips_assert, store_overlap_status(), type_variable, type_variable_p, and variable_dimensions.

Referenced by get_overlap(), and set_overlap().

Here is the call graph for this function:

Here is the caller graph for this function:

declaration_with_overlaps()

static void declaration_with_overlaps ( list  l )

static

arguments are passed the declarations from outside

??? memory leak

Definition at line 780 of file declarations.c.

{
    entity ent;
    int ndim, i, lower_overlap, upper_overlap;
    dimension the_dim;
 
    MAP(ENTITY, oldent,
     {
         ent = load_new_node(oldent);
         ndim = variable_entity_dimension(ent);
 
         pips_assert("variable", type_variable_p(entity_type(ent)));
 
         if (storage_formal_p(entity_storage(ent)))
         {
             /* arguments are passed the declarations from outside
              */
             for (i=1 ; i<=ndim ; i++)
             {
                 if (ith_dim_overlapable_p(oldent, i))
                 {
                     the_dim = entity_ith_dimension(ent, i); 
                     dimension_lower(the_dim) = /* ??? memory leak */
                        hpfc_array_bound(ent, false, i);
                     dimension_upper(the_dim) = 
                        hpfc_array_bound(ent, true, i);
                 }
             }
         }
         else
         {
             for (i=1 ; i<=ndim ; i++)
             {
                 the_dim = entity_ith_dimension(ent, i);
                 lower_overlap = get_overlap(oldent, i, 0);
                 upper_overlap = get_overlap(oldent, i, 1);
                 
                 pips_debug(8, "%s(DIM=%d): -%d, +%d\n", 
                            entity_name(ent), i, lower_overlap, upper_overlap);
                 
                 if (lower_overlap!=0) 
                     overlap_redefine_expression(&dimension_lower(the_dim),
                                                 -lower_overlap);
                 
                 if (upper_overlap!=0) 
                     overlap_redefine_expression(&dimension_upper(the_dim),
                                                 upper_overlap);
             }
         }
     },
         l);
}

References dimension_lower, dimension_upper, ENTITY, entity_ith_dimension(), entity_name, entity_storage, entity_type, get_overlap(), hpfc_array_bound(), ith_dim_overlapable_p(), load_new_node(), MAP, overlap_redefine_expression(), pips_assert, pips_debug, storage_formal_p, type_variable_p, and variable_entity_dimension().

Referenced by declaration_with_overlaps_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

declaration_with_overlaps_for_module()

void declaration_with_overlaps_for_module

(

entity

module

)

Parameters

module

odule

Definition at line 835 of file declarations.c.

{
    list l = list_of_distributed_arrays_for_module(module);
    declaration_with_overlaps(l);
    gen_free_list(l);
}

References declaration_with_overlaps(), gen_free_list(), list_of_distributed_arrays_for_module(), and module.

Referenced by compile_common(), and compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_hpf_number()

expression entity_hpf_number

(

entity

e

)

returns the hpf_number parameter as a string not really needed ??? ??? never called

Definition at line 196 of file declarations.c.

{
    storage
        s = entity_storage(e);
    bool
        in_common = entity_in_common_p(e),
        in_ram = storage_ram_p(s);
    ram 
        r = (in_ram ? storage_ram(s) : ram_undefined);
        const char* suffix = entity_local_name(e),
        *prefix = 
            (in_ram ? 
             entity_local_name(in_common ? ram_section(r) : ram_function(r)) :
             "DEFAULT");
 
    pips_assert("ram variable", entity_variable_p(e) && in_ram);
 
    return(MakeCharacterConstantExpression
           (strdup(concatenate("n_", prefix, "_", suffix, NULL))));
                           
}

References concatenate(), entity_in_common_p(), entity_local_name(), entity_storage, entity_variable_p, MakeCharacterConstantExpression(), pips_assert, prefix, ram_function, ram_section, ram_undefined, storage_ram, storage_ram_p, and strdup().

Here is the call graph for this function:

expression_constant_p()

bool expression_constant_p

(

expression

exp

)

HPFC module by Fabien COELHO.

new declarations compilation. normalization of HPF declarations.

HPFC module by Fabien COELHO.

bool expression_constant_p(expression exp) Returns true if "exp" is an (integer) constant value.

Note : A negativePositive constant can be represented with a call to the unary minus/plus intrinsic function upon a positive value.

See below extended_expression_constant_p() for a more general function.

Definition at line 2453 of file expression.c.

{
  return !constant_undefined_p(expression_constant(exp));
}

References constant_undefined_p, exp, and expression_constant().

Referenced by add_const_expr_p(), analyze_expression(), array_indices_check(), array_size_stride(), atom_cse_expression(), atomize_this_expression(), compute_final_index_value(), constant_step_loop_p(), constraints_to_loop_bound(), do_loop_expansion(), do_loop_expansion_init(), do_solve_hardware_constraints_on_volume(), effect_field_dimension_entity(), equal_must_vreference(), expression_plusplus(), expression_try_find_size(), formal_variable_add_aliases(), freia_insert_added_stats(), incrementation_expression_to_increment(), inline_expression_call(), loop_annotate(), loop_normalize_of_loop(), make_loadsave_statement(), make_max_exp(), make_send_receive_conversion(), MakeCaseStatement(), MakeEquivAtom(), malloc_arg_to_type(), normalizable_loop_p(), opkill_may_vreference(), opkill_must_vreference(), overlap_redefine_expression(), plc_make_dim(), points_to_compare_cell(), points_to_compare_cells(), points_to_compare_location(), points_to_compare_ptr_cell(), process_true_call_stat(), rational_op_exp(), replace_subscript(), size_of_dummy_array(), sp_feautrier_expression_p(), splc_feautrier_expression_p(), stmt_bdt_directions(), subscript_value(), terapixify_loops(), valuer(), and words_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

free_hpf_object_lists()

void free_hpf_object_lists

(

void

)

Definition at line 98 of file declarations.c.

{
    gen_free_list(distributed_arrays),
    gen_free_list(templates),
    gen_free_list(processors);
 
    reset_hpf_object_lists();
}

References gen_free_list(), and reset_hpf_object_lists().

Referenced by close_data_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_data_status()

data_status get_data_status

(

void

)

??? previsous data_status lost: memory leak

Definition at line 308 of file declarations.c.

{
    /* ??? previsous data_status lost: memory leak
     */
    return(make_data_status(get_new_declaration(),
                            get_hpf_alignment(), 
                            get_hpf_distribution(),                         
                            list_of_distributed_arrays(),
                            list_of_templates(),
                            list_of_processors()));
}

References get_hpf_alignment(), get_hpf_distribution(), list_of_distributed_arrays(), list_of_processors(), list_of_templates(), and make_data_status().

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_hpf_number_status()

numbers_status get_hpf_number_status

(

void

)

Definition at line 134 of file declarations.c.

{
    return(make_numbers_status(get_hpf_number(),
                               current_array_index,
                               current_template_index,
                               current_processors_index));
}

References current_array_index, current_processors_index, current_template_index, get_hpf_number(), and make_numbers_status().

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_ith_dim_new_declaration()

void get_ith_dim_new_declaration	(	entity	array,
		int	i,
		int *	pmin,
		int *	pmax
	)

Parameters

array	rray
pmin	min
pmax	max

Definition at line 285 of file declarations.c.

{
    dimension d = entity_ith_dimension(load_new_node(array), i);
 
    pips_assert("distributed array",
                array_distributed_p(array) && entity_variable_p(array));
 
    *pmin = HpfcExpressionToInt(dimension_lower(d));
    *pmax = HpfcExpressionToInt(dimension_upper(d));
}

References array, array_distributed_p(), dimension_lower, dimension_upper, entity_ith_dimension(), entity_variable_p, HpfcExpressionToInt(), load_new_node(), and pips_assert.

Referenced by hpfc_compute_entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

get_overlap()

int get_overlap	(	entity	ent,
		int	dim,
		int	side
	)

returns the overlap for a given entity, dimension and side, to be used in the declaration modifications

Parameters

ent	nt
dim	im
side	ide

Definition at line 743 of file declarations.c.

{
    overlap o;
 
    pips_assert("valid dimension", dim>0);
    pips_debug(10, "%s (DIM=%d) %s\n", entity_name(ent), dim, side?"+":"-");
 
    if (!bound_overlap_status_p(ent)) create_overlaps(ent);
    pips_assert("overlap ok", bound_overlap_status_p(ent));
 
    o = OVERLAP(gen_nth(dim-1, load_overlap_status(ent)));
    return(side ? overlap_upper(o) : overlap_lower(o));
}

References bound_overlap_status_p(), create_overlaps(), entity_name, gen_nth(), load_overlap_status(), OVERLAP, overlap_lower, overlap_upper, pips_assert, and pips_debug.

Referenced by declaration_with_overlaps(), and update_overlaps_of().

Here is the call graph for this function:

Here is the caller graph for this function:

GiveToHpfObjectsTheirNumber()

void GiveToHpfObjectsTheirNumber

(

void

)

give to hpf objects listed in distributedarrays, templates and processors their number for the code generation...

Definition at line 166 of file declarations.c.

{
    pips_debug(7, "Here I am!\n");
 
    MAP(ENTITY, e,
    {
        if (!bound_hpf_number_p(e))
            store_hpf_number(e, current_array_index++);
    },
        distributed_arrays);
 
    MAP(ENTITY, e,
    {
        if (!bound_hpf_number_p(e))
            store_hpf_number(e, current_template_index++);
    },
        templates);
 
    MAP(ENTITY, e,
    {
        if (!bound_hpf_number_p(e))
            store_hpf_number(e, current_processors_index++);
    },
        processors);
}

References bound_hpf_number_p(), current_array_index, current_processors_index, current_template_index, ENTITY, MAP, pips_debug, and store_hpf_number().

Referenced by NormalizeHpfDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

init_currents()

static void init_currents ( )

static

Definition at line 116 of file declarations.c.

{
    current_array_index = 1,
    current_template_index = 1,
    current_processors_index = 1;
}

References current_array_index, current_processors_index, and current_template_index.

Referenced by close_hpf_number_status(), init_hpf_number_status(), and reset_hpf_number_status().

Here is the caller graph for this function:

init_data_status()

void init_data_status

(

void

)

Definition at line 300 of file declarations.c.

{
    init_new_declaration();
    init_hpf_alignment();
    init_hpf_distribution();
    reset_hpf_object_lists();
}

References init_hpf_alignment(), init_hpf_distribution(), and reset_hpf_object_lists().

Referenced by init_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

init_hpf_number_status()

void init_hpf_number_status

(

void

)

STANDARS STATIC MANAGEMENT.

functions: {init,get,set,reset,close}_hpf_number_status

Definition at line 128 of file declarations.c.

{
    init_hpf_number();
    init_currents();
}

References init_currents(), and init_hpf_number().

Referenced by init_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_distributed_arrays_for_module()

list list_of_distributed_arrays_for_module

(

entity

module

)

returns the list of entities that are 'local' to module

Parameters

module

odule

Definition at line 72 of file declarations.c.

{
    list l = NIL;
 
    MAP(ENTITY, e,
    {
        if (hpfc_main_entity(e)==module) l = CONS(ENTITY, e, l);
    },
        list_of_distributed_arrays());
 
    return(l);
}

References CONS, ENTITY, hpfc_main_entity(), list_of_distributed_arrays(), MAP, module, and NIL.

Referenced by create_init_common_param_for_arrays(), create_parameters_h(), declaration_with_overlaps_for_module(), and root_statement_remapping_inits().

Here is the call graph for this function:

Here is the caller graph for this function:

new_declaration_tag()

tag new_declaration_tag	(	entity	array,
		int	dim
	)

Parameters

array	rray
dim	im

Definition at line 229 of file declarations.c.

{
    tag t;
 
    pips_assert("valid dimension and distributed array",
                dim>0 && dim<=7 && array_distributed_p(array));
 
    t = hpf_newdecl_tag
        (HPF_NEWDECL(gen_nth(dim-1, 
         hpf_newdecls_dimensions(load_new_declaration(array)))));
 
    pips_debug(1, "%s[%d]: %d\n", entity_name(array), dim, t);
 
    return(t);
}

References array, array_distributed_p(), entity_name, gen_nth(), HPF_NEWDECL, hpf_newdecl_tag, hpf_newdecls_dimensions, pips_assert, and pips_debug.

Referenced by block_distributed_p(), create_init_common_param_for_arrays(), expr_compute_local_index(), and hpfc_compute_entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

NewDeclarationOfDistributedArray()

static void NewDeclarationOfDistributedArray ( entity  array )

static

for node this are reformated, and for host these variables are deleted.

it may happen that no newarray is available, when a module with no distributed variables is considered...

compute the new size for every dimension on the array, then update the dimensions of the newarray. remember that the dimensions are shared between the old and new arrays.

Definition at line 615 of file declarations.c.

{
    entity newarray;
    int ithdim = 1, newsz, p;
    tag newdecl;
    list ld = NIL;
 
    /* it may happen that no newarray is available, 
     * when a module with no distributed variables is considered...
     */
    if (!bound_new_node_p(array)) return;
    newarray = load_new_node(array);
    pips_assert("distributed array",
                array_distributed_p(array) && entity_variable_p(array));
 
    pips_debug(6, "considering array %s, new %s\n",
               entity_name(array), entity_name(newarray));
 
    /* compute the new size for every dimension on the array,
     * then update the dimensions of the newarray. remember
     * that the dimensions are shared between the old and new arrays.
     */
    MAP(DIMENSION, dim,
    {
        if (ith_dim_distributed_p(array, ithdim, &p))
        {
            newsz = ComputeNewSizeOfIthDimension(dim, ithdim, array, &newdecl);
            
            pips_debug(8, "dimension %d new size: %d\n", ithdim, newsz);
             
            ld = gen_nconc(ld,
                           CONS(DIMENSION,
                                make_dimension(int_to_expression(1),
                                               int_to_expression(newsz),
                                               NIL),
                                NIL));
            
        }
        else
        {
            pips_debug(8, "dimension %d isn't touched\n", ithdim);
            
            newdecl = is_hpf_newdecl_none;
            ld = gen_nconc(ld, CONS(DIMENSION, copy_dimension(dim), NIL));
        }
        
        store_a_new_declaration(array, ithdim, newdecl);
        
        ithdim++;
    },
        variable_dimensions(type_variable(entity_type(array))));
    
    variable_dimensions(type_variable(entity_type(newarray)))=ld;
}

References array, array_distributed_p(), bound_new_node_p(), ComputeNewSizeOfIthDimension(), CONS, copy_dimension(), DIMENSION, entity_name, entity_type, entity_variable_p, gen_nconc(), int_to_expression(), is_hpf_newdecl_none, ith_dim_distributed_p(), load_new_node(), make_dimension(), MAP, NIL, pips_assert, pips_debug, store_a_new_declaration(), type_variable, and variable_dimensions.

Referenced by NewDeclarationsOfDistributedArrays().

Here is the call graph for this function:

Here is the caller graph for this function:

NewDeclarationsOfDistributedArrays()

void NewDeclarationsOfDistributedArrays

(

void

)

this procedure generate the new declarations of every distributed arrays of the program, in order to minimize the amount of memory used.

The new declarations have to be suitable for the new index computation which is to be done dynamically...

Definition at line 676 of file declarations.c.

{
    MAP(ENTITY, array,
    {
        if (!bound_new_declaration_p(array))
            NewDeclarationOfDistributedArray(array);
        else
            pips_debug(3, "skipping array %s\n", entity_name(array));
    },
        list_of_distributed_arrays());
}

References array, ENTITY, entity_name, list_of_distributed_arrays(), MAP, NewDeclarationOfDistributedArray(), and pips_debug.

Referenced by init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_align()

void normalize_align	(	_UNUSED_ entity	e,
		align	a
	)

Definition at line 426 of file declarations.c.

{
    normalize_first_expressions_of(a);
}

References normalize_first_expressions_of().

Referenced by one_align_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_distribute()

void normalize_distribute	(	entity	t,
		distribute	d
	)

of distribution

Definition at line 408 of file declarations.c.

{
    entity p = distribute_processors(d);
    list /* of distribution */ ld = distribute_distribution(d);
    int tdim = 1, pdim = 1;
 
    normalize_first_expressions_of(d);
    
    MAP(DISTRIBUTION, di,
        NormalizeOneTemplateDistribution(di, t, &tdim, p, &pdim), ld);
 
    if ((pdim-1)!=NumberOfDimension(p))
        pips_user_error("%s not enough distributions\n", entity_name(t));
                   
}

References distribute_distribution, distribute_processors, DISTRIBUTION, entity_name, MAP, normalize_first_expressions_of(), NormalizeOneTemplateDistribution(), NumberOfDimension(), and pips_user_error.

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_hpf_object()

void normalize_hpf_object

(

entity

v

)

Definition at line 431 of file declarations.c.

{
    normalize_first_expressions_of(entity_type(v));
}

References entity_type, and normalize_first_expressions_of().

Here is the call graph for this function:

NormalizeHpfDeclarations()

void NormalizeHpfDeclarations

(

void

)

Definition at line 437 of file declarations.c.

{
    GiveToHpfObjectsTheirNumber();
    ifdebug(8){print_hpf_dir();}
}

References GiveToHpfObjectsTheirNumber(), ifdebug, and print_hpf_dir().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeOneTemplateDistribution()

static void NormalizeOneTemplateDistribution ( distribution  d, entity  templ, int *  templdimp, entity  procs, int *  procsdimp  )

static

NormalizeOneTemplateDistribution.

compute the missing value, in case of BLOCK distribution

check the given value

Definition at line 352 of file declarations.c.

{
    if (style_none_p(distribution_style(d)))
        (*templdimp)++;
    else
    {
        int szoftempldim = SizeOfIthDimension(templ,(*templdimp)),
            szofprocsdim = SizeOfIthDimension(procs,(*procsdimp));
        
        if (distribution_parameter(d)==expression_undefined)
        {
            /* compute the missing value, in case of BLOCK distribution
             */
            
            switch(style_tag(distribution_style(d)))
            {
            case is_style_block:
                distribution_parameter(d)=
                    int_to_expression(iceil(szoftempldim, szofprocsdim));
                break;
            default:
                pips_internal_error("undefined style tag");
                break;
            }
        }
        else
        {
            /* check the given value
             */
            
            int paramvalue = HpfcExpressionToInt(distribution_parameter(d));
            
            switch(style_tag(distribution_style(d)))
            {
            case is_style_block:
            {
                int minvalue = iceil(szoftempldim, szofprocsdim);
                
                if (paramvalue<minvalue) 
                    pips_user_error("block too small in %s distribution\n",
                                    entity_name(templ));
                break;
            }
            default:
                break;
            }
        }
        
        (*templdimp)++;
        (*procsdimp)++;
    }
}

References distribution_parameter, distribution_style, entity_name, expression_undefined, HpfcExpressionToInt(), iceil, int_to_expression(), is_style_block, pips_internal_error, pips_user_error, SizeOfIthDimension(), style_none_p, and style_tag.

Referenced by normalize_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

overlap_redefine_expression()

static void overlap_redefine_expression ( expression *  pexpr, int  ov  )

static

redefines the bound given the overlap which is to be included

this avoid a memory leak

Definition at line 761 of file declarations.c.

{
    expression
        copy = *pexpr;
 
    if (expression_constant_p(*pexpr))
    {
        *pexpr = int_to_expression(HpfcExpressionToInt(*pexpr)+ov);
        free_expression(copy); /* this avoid a memory leak */
    }
    else
        *pexpr = MakeBinaryCall(FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, 
                                                   PLUS_OPERATOR_NAME),
                                *pexpr,
                                int_to_expression(ov));
}

References expression_constant_p(), FindOrCreateEntity(), free_expression(), HpfcExpressionToInt(), int_to_expression(), MakeBinaryCall(), PLUS_OPERATOR_NAME, and TOP_LEVEL_MODULE_NAME.

Referenced by declaration_with_overlaps().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_data_status()

void reset_data_status

(

void

)

Definition at line 320 of file declarations.c.

{
    reset_new_declaration();
    reset_hpf_alignment();
    reset_hpf_distribution();
    reset_hpf_object_lists();
}

References reset_hpf_alignment(), reset_hpf_distribution(), and reset_hpf_object_lists().

Referenced by reset_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_hpf_number_status()

void reset_hpf_number_status

(

void

)

Definition at line 142 of file declarations.c.

{
    reset_hpf_number();
    init_currents();
}

References init_currents(), and reset_hpf_number().

Referenced by reset_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_hpf_object_lists()

void reset_hpf_object_lists

(

void

)

Definition at line 91 of file declarations.c.

{
    distributed_arrays = NIL,
    templates = NIL,
    processors = NIL;
}

References NIL.

Referenced by free_hpf_object_lists(), init_data_status(), and reset_data_status().

Here is the caller graph for this function:

set_data_status()

void set_data_status

(

data_status

s

)

Definition at line 328 of file declarations.c.

{
    set_new_declaration(data_status_newdeclmap(s));
    set_hpf_alignment(data_status_alignmap(s));
    set_hpf_distribution(data_status_distributemap(s));
    distributed_arrays = data_status_arrays(s);
    templates = data_status_templates(s);
    processors = data_status_processors(s);
}

References data_status_alignmap, data_status_arrays, data_status_distributemap, data_status_newdeclmap, data_status_processors, data_status_templates, set_hpf_alignment(), and set_hpf_distribution().

Referenced by load_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_hpf_number_status()

void set_hpf_number_status

(

numbers_status

s

)

Definition at line 148 of file declarations.c.

{
    set_hpf_number(numbers_status_numbermap(s));
    current_array_index = numbers_status_arrays(s);
    current_template_index = numbers_status_templates(s);
    current_processors_index = numbers_status_processors(s);
}

References current_array_index, current_processors_index, current_template_index, numbers_status_arrays, numbers_status_numbermap, numbers_status_processors, numbers_status_templates, and set_hpf_number().

Referenced by load_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_overlap()

void set_overlap	(	entity	ent,
		int	dim,
		int	side,
		int	width
	)

set the overlap value for entity ent, on dimension dim, dans side side to width, which must be a positive integer.

if necessary, the overlap is updates with the value width.

upper

lower

Parameters

ent	nt
dim	im
side	ide
width	idth

Definition at line 713 of file declarations.c.

{
    overlap o;
    int current;
 
    pips_assert("valid dimension", dim>0);
 
    pips_debug(10, "%s:(DIM=%d) %s%d\n", 
               entity_name(ent), dim, side?"+":"-", width);
 
    if (!bound_overlap_status_p(ent)) create_overlaps(ent);
    o = OVERLAP(gen_nth(dim-1, load_overlap_status(ent)));
 
    if (side) /* upper */
    {
        current = overlap_upper(o);
        if (current<width) overlap_upper(o)=width;
    }
    else /* lower */
    {
        current = overlap_lower(o);
        if (current<width) overlap_lower(o)=width;
    }
}

References bound_overlap_status_p(), create_overlaps(), current, entity_name, gen_nth(), load_overlap_status(), OVERLAP, overlap_lower, overlap_upper, pips_assert, and pips_debug.

Referenced by message_manageable_p(), and update_overlaps_of().

Here is the call graph for this function:

Here is the caller graph for this function:

STATIC_LIST_OF_HPF_OBJECTS()

STATIC_LIST_OF_HPF_OBJECTS	(	distributed_arrays	,
		set_array_as_distributed	,
		array_distributed_p
	)

Definition at line 54 of file declarations.c.

{
    bool
        distributed = 
            (array_distributed_p(e) ||
             array_distributed_p(load_old_host(e)) ||
             array_distributed_p(load_old_node(e))),
        in_common = entity_in_common_p(e);
 
    return(distributed && in_common);
}

References array_distributed_p(), entity_in_common_p(), load_old_host(), and load_old_node().

Here is the call graph for this function:

store_a_new_declaration()

static void store_a_new_declaration ( entity  array, int  dim, tag  what  )

static

Definition at line 266 of file declarations.c.

{
    hpf_newdecl n;
 
    pips_assert("valid dimension and distributed array",
                dim>0 && dim<=7 && array_distributed_p(array));
 
    if (!bound_new_declaration_p(array))
        create_new_declaration(array);
 
    n = HPF_NEWDECL(gen_nth(dim-1, 
            hpf_newdecls_dimensions(load_new_declaration(array))));
 
    hpf_newdecl_tag(n) = what;
}

References array, array_distributed_p(), create_new_declaration(), gen_nth(), HPF_NEWDECL, hpf_newdecl_tag, hpf_newdecls_dimensions, and pips_assert.

Referenced by NewDeclarationOfDistributedArray().

Here is the call graph for this function:

Here is the caller graph for this function:

update_overlaps_in_caller()

void update_overlaps_in_caller	(	entity	fun,
		list	le
	)

the overlaps of the actual parameters are updated according to the formal requirements.

Parameters

fun	un
le	the function of expression call arguments in the initial code

Definition at line 864 of file declarations.c.

{
    int len = gen_length(le), i;
    for (i=1; i<=len; i++, POP(le))
    {
        entity v = find_ith_parameter(fun, i);
        if (array_distributed_p(v))
        {
            expression e = EXPRESSION(CAR(le));
            entity u = expression_to_entity(e), nu;
            pips_assert("bounded to a new var", bound_new_node_p(u));
            nu = load_new_node(u);
            pips_debug(5, "call to %s, %s (%s) -> %s\n", 
                       entity_name(fun), entity_name(u), 
                       entity_name(nu), entity_name(v));
            update_overlaps_of(u, v);
        }
 
    }
}

References array_distributed_p(), bound_new_node_p(), CAR, entity_name, EXPRESSION, expression_to_entity(), find_ith_parameter(), gen_length(), load_new_node(), pips_assert, pips_debug, POP, and update_overlaps_of().

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

update_overlaps_of()

static void update_overlaps_of ( entity  u, entity  v  )

static

Parameters

u	distributed variable in the caller
v	formal parameter in the callee

Definition at line 843 of file declarations.c.

{
    int ndim = NumberOfDimension(v);
 
    pips_assert("conformance", ndim==NumberOfDimension(u));
 
    pips_debug(7, "%s from %s\n", entity_name(u), entity_name(v));
 
    for(; ndim>0; ndim--)
    {
        set_overlap(u, ndim, 0, get_overlap(v, ndim, 0));
        set_overlap(u, ndim, 1, get_overlap(v, ndim, 1));
    }
}

References entity_name, get_overlap(), NumberOfDimension(), pips_assert, pips_debug, and set_overlap().

Referenced by update_overlaps_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

current_array_index

int current_array_index = 1

static

Definition at line 112 of file declarations.c.

Referenced by get_hpf_number_status(), GiveToHpfObjectsTheirNumber(), init_currents(), and set_hpf_number_status().

current_processors_index

int current_processors_index = 1

static

Definition at line 114 of file declarations.c.

Referenced by get_hpf_number_status(), GiveToHpfObjectsTheirNumber(), init_currents(), and set_hpf_number_status().

current_template_index

int current_template_index = 1

static

Definition at line 113 of file declarations.c.

Referenced by get_hpf_number_status(), GiveToHpfObjectsTheirNumber(), init_currents(), and set_hpf_number_status().