hpfc-util.c File Reference

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

Include dependency graph for hpfc-util.c:

Go to the source code of this file.

Macros
#define	XDEBUG(msg)    pips_debug(6, "%s and %s: " msg "\n", entity_name(e1), entity_name(e2))

Functions
bool	ref_to_dist_array_p (void *obj)
	this file describe a few functions usefull to the compiler to manage the hpfc data structures. More...
bool	written_effect_p (entity var, list le)
	written_effects_to_dist_arrays_p More...
bool	written_effects_to_dist_arrays_p (expression expr)
bool	replicated_p (entity e)
	replicated_p More...
bool	ith_dim_replicated_p (_UNUSED_ entity template, int i, list la, distribution dist)
	bool ith_dim_replicated_p(template, i, la, dist) More...
bool	processors_dim_replicated_p (_UNUSED_ entity p, entity a, int i)
	true if array a is replicated on processors p i-th dimension. More...
bool	ith_dim_distributed_p (entity array, int i, int *pprocdim)
	whether a dimension is distributed or not. More...
bool	ith_dim_overlapable_p (entity array, int i)
statement	MakeStatementLike (statement stat, int the_tag)
	creates a new statement for the given module that looks like the stat one, i.e. More...
static void	stmt_rwt (statement s)
void	kill_statement_number_and_ordering (statement s)
list	DistArraysEffects (expression expr)
	effects' action in an expression are here supposed to be read one's but that may not be correct? More...
list	FindRefToDistArrayFromList (list lexpr)
	FindRefToDistArrayFromList. More...
static void	FindRefToDistArray_syntax_rewrite (syntax s)
list	FindRefToDistArray (void *obj)
void	AddEntityToHostAndNodeModules (entity e)
	AddEntityToHostAndNodeModules. More...
void	AddCommonToModule (entity common, entity module, void(*update)(), string suffix)
	The common name is changed to distinguish the current, host and node instances of the common. More...
void	AddCommonToHostAndNodeModules (entity common)
alignment	FindAlignmentOfDim (list lal, int dim)
alignment	FindAlignmentOfTemplateDim (list lal, int dim)
distribution	FindDistributionOfDim (list ldi, int dim, int *pdim)
distribution	FindDistributionOfProcessorDim (list ldi, int dim, int *tdim)
int	template_dimension_of_array_dimension (entity array, int dim)
int	processor_dimension_of_template_dimension (entity template, int dim)
int	DistributionParameterOfArrayDim (entity array, int dim, int *pprocdim)
int	processor_number (entity template, int tdim, int tcell, int *pprocdim)
	int processor_number(template, tdim, tcell, pprocdim) More...
int	template_cell_local_mapping (entity array, int dim, int tc)
	int template_cell_local_mapping(array, dim, tc) More...
int	global_array_cell_to_local_array_cell (entity array, int dim, int acell)
	int global_array_cell_to_local_array_cell(array, dim, acell) More...
int	HpfcExpressionToInt (expression e)
	HpfcExpressionToInt(e) More...
void	get_alignment (entity array, int dim, int *ptdim, int *pa, int *pb)
void	get_distribution (entity template, int dim, int *ppdim, int *pn)
void	get_entity_dimensions (entity e, int dim, int *plow, int *pup)
bool	alignments_compatible_p (entity e1, int dim1, entity e2, int dim2)
	bool alignments_compatible_p(entity e1, int dim1, entity e2, int dim2) More...
static int	expression_number_for_index (entity index, list le)
	bool references_aligned_p(reference r1, reference r2) More...
bool	references_aligned_p (reference r1, reference r2)
void	hpfc_util_error_handler ()
	removes IF (.TRUE.) THEN and DO X=n, n More...
static void	test_rewrite (test t)
static void	loop_rewrite (loop l)
void	statement_structural_cleaning (statement s)

Variables
static list	found_syntaxes = NIL

Macro Definition Documentation

XDEBUG

#define XDEBUG

(

msg

)

pips_debug(6, "%s and %s: " msg "\n", entity_name(e1), entity_name(e2))

Definition at line 722 of file hpfc-util.c.

Function Documentation

AddCommonToHostAndNodeModules()

void AddCommonToHostAndNodeModules

(

entity

common

)

Parameters

common

ommon

Definition at line 371 of file hpfc-util.c.

{
    AddCommonToModule(common, node_module, (void (*)())store_new_node_variable, NODE_NAME);
    AddCommonToModule(common, host_module, (void (*)())store_new_host_variable, HOST_NAME);
}

References AddCommonToModule(), host_module, HOST_NAME, node_module, NODE_NAME, store_new_host_variable(), and store_new_node_variable().

Referenced by init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

AddCommonToModule()

void AddCommonToModule	(	entity	common,
		entity	module,
		void (*)()	update,
		string	suffix
	)

The common name is changed to distinguish the current, host and node instances of the common.

The layout list must be updated to the right entities

!!! not in current

Definition at line 328 of file hpfc-util.c.

{
    string name = strdup(concatenate(entity_local_name(common),
                                     "_", suffix, NULL));
    entity new_common = 
        FindOrCreateEntityLikeModel(HPFC_PACKAGE, name, common);
    list 
        lref = area_layout(type_area(entity_type(common))),
        lold = area_layout(type_area(entity_type(new_common))),
        lnew = NIL;
 
    free(name);
    update(new_common, common);
 
    /* The layout list must be updated to the right entities
     */
 
    MAP(ENTITY, e,
    {
        entity new_e;
        
        if (local_entity_of_module_p(e, common)) /* !!! not in current  */
        {
            new_e = AddEntityToModule(e, new_common);
            
            if (gen_find_eq(new_e, lold)==entity_undefined)
            {
                lnew = CONS(ENTITY, new_e, lnew);
                update(new_e, e);
            }
        }
    },
        lref);
 
    AddEntityToDeclarations(new_common, module);
 
    area_layout(type_area(entity_type(new_common))) = 
        gen_nconc(gen_nreverse(lnew), lold);
}

References AddEntityToDeclarations(), AddEntityToModule(), area_layout, concatenate(), CONS, ENTITY, entity_local_name(), entity_type, entity_undefined, FindOrCreateEntityLikeModel(), free(), gen_find_eq(), gen_nconc(), gen_nreverse(), HPFC_PACKAGE, local_entity_of_module_p(), MAP, module, NIL, strdup(), and type_area.

Referenced by AddCommonToHostAndNodeModules().

Here is the call graph for this function:

Here is the caller graph for this function:

AddEntityToHostAndNodeModules()

void AddEntityToHostAndNodeModules

(

entity

e

)

AddEntityToHostAndNodeModules.

added because of some entity errors.

Definition at line 298 of file hpfc-util.c.

{
    entity new_node = AddEntityToModule(e, node_module),
           new_host = entity_undefined;
 
    if (!bound_new_node_p(e))
        store_new_node_variable(new_node, e);
    else
        AddEntityToDeclarations(load_new_node(e), node_module);
 
    if (!array_distributed_p(e))
    {
        new_host = AddEntityToModule(e, host_module);
 
        if (!bound_new_host_p(e))
            store_new_host_variable(new_host, e),
            /* 
             * added because of some entity errors.
             */
            store_new_host(new_node, new_host),
            store_new_node(new_host, new_node); 
        else
            AddEntityToDeclarations(load_new_host(e), host_module);
    }
}

References AddEntityToDeclarations(), AddEntityToModule(), array_distributed_p(), bound_new_host_p(), bound_new_node_p(), entity_undefined, host_module, load_new_host(), load_new_node(), node_module, store_new_host(), store_new_host_variable(), store_new_node(), and store_new_node_variable().

Referenced by generate_parallel_body(), generate_read_of_ref_for_all(), generate_read_of_ref_for_computer(), generate_update_distributed_value_from_host(), and init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

alignments_compatible_p()

bool alignments_compatible_p	(	entity	e1,
		int	dim1,
		entity	e2,
		int	dim2
	)

bool alignments_compatible_p(entity e1, int dim1, entity e2, int dim2)

what: whether e1 and e2 dimensions dim1 and dim2 are aligned. how: basic low level comparison input: entities and dimension numbers output: the bool result side effects:

• uses alignment internal descriptions bugs or features:
• ??? should be relative to a reference, instead of assuming mere indexes

Parameters

e1	1
dim1	im1
e2	2
dim2	im2

Definition at line 678 of file hpfc-util.c.

{
    int tdim1, rate1, shift1, tdim2, rate2, shift2;
 
    get_alignment(e1, dim1, &tdim1, &rate1, &shift1);
    get_alignment(e2, dim2, &tdim2, &rate2, &shift2);
 
    if (tdim1!=tdim2) return false;
    if (!tdim1 && !tdim2) return true;
    
    return rate1==rate2 && shift1==shift2;
}

References get_alignment().

Referenced by references_aligned_p().

Here is the call graph for this function:

Here is the caller graph for this function:

DistArraysEffects()

list DistArraysEffects

(

expression

expr

)

effects' action in an expression are here supposed to be read one's but that may not be correct?

Parameters

expr

xpr

Definition at line 241 of file hpfc-util.c.

{
    list le = proper_effects_of_expression(expr), lde = NIL;
 
    FOREACH(EFFECT, e, le) {
      if(store_effect_p(e)) {
        if (array_distributed_p(effect_variable(e)))
          lde=CONS(EFFECT,e,lde);
      }
    }
 
    gen_free_list(le);
    return(lde);
}

References array_distributed_p(), CONS, EFFECT, effect_variable, FOREACH, gen_free_list(), NIL, proper_effects_of_expression(), and store_effect_p().

Referenced by written_effects_to_dist_arrays_p().

Here is the call graph for this function:

Here is the caller graph for this function:

DistributionParameterOfArrayDim()

int DistributionParameterOfArrayDim	(	entity	array,
		int	dim,
		int *	pprocdim
	)

Parameters

array	rray
dim	im
pprocdim	procdim

Definition at line 472 of file hpfc-util.c.

{
    entity template = array_to_template(array);
    distribute d = load_hpf_distribution(template);
    distribution
        di = FindDistributionOfDim
            (distribute_distribution(d),
             alignment_templatedim(FindArrayDimAlignmentOfArray(array, dim)),
             pprocdim);
    
    return HpfcExpressionToInt(distribution_parameter(di));
}

References alignment_templatedim, array, array_to_template, distribute_distribution, distribution_parameter, FindArrayDimAlignmentOfArray, FindDistributionOfDim(), HpfcExpressionToInt(), and load_hpf_distribution().

Referenced by generate_one_message(), message_manageable_p(), shape_one_message(), and template_cell_local_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_number_for_index()

static int expression_number_for_index ( entity  index, list  le  )

static

bool references_aligned_p(reference r1, reference r2)

what: tells whether the references are aligned or not how: quite basic and low level input: both references output: the returned boolean side effects:

• uses alignment internal descriptions bugs or features:
• assumes that both references are in the same store.
• ??? indices must be simple references to indexes. returns 0 if not found

Parameters

le	of expression

Definition at line 706 of file hpfc-util.c.

{
    int dim=1;
 
    MAP(EXPRESSION, e,
    {
        if (expression_reference_p(e) && 
            reference_variable(syntax_reference(expression_syntax(e)))==index)
            return dim;
        dim++;
    },
        le);
 
    return 0;
}

References EXPRESSION, expression_reference_p(), expression_syntax, MAP, reference_variable, and syntax_reference.

Referenced by references_aligned_p().

Here is the call graph for this function:

Here is the caller graph for this function:

FindAlignmentOfDim()

alignment FindAlignmentOfDim	(	list	lal,
		int	dim
	)

Parameters

lal	al
dim	im

Definition at line 377 of file hpfc-util.c.

{
    list l=lal;
 
    while ((!ENDP(l)) && (alignment_arraydim(ALIGNMENT(CAR(l))) != dim))
        POP(l);
 
    return (l==NIL) ? alignment_undefined : ALIGNMENT(CAR(l));
}

References ALIGNMENT, alignment_arraydim, alignment_undefined, CAR, ENDP, NIL, and POP.

Referenced by ComputeNewSizeOfIthDimension(), create_init_common_param_for_arrays(), expr_compute_local_index(), ith_dim_distributed_p(), ith_dim_overlapable_p(), and template_dimension_of_array_dimension().

Here is the caller graph for this function:

FindAlignmentOfTemplateDim()

alignment FindAlignmentOfTemplateDim	(	list	lal,
		int	dim
	)

Parameters

lal	al
dim	im

Definition at line 389 of file hpfc-util.c.

{
    list l=lal;
 
    while ((!ENDP(l)) && (alignment_templatedim(ALIGNMENT(CAR(l))) != dim))
        POP(l);
 
    return ((l==NULL)?(alignment_undefined):(ALIGNMENT(CAR(l))));
}

References ALIGNMENT, alignment_templatedim, alignment_undefined, CAR, ENDP, and POP.

Referenced by array_distribution_similar_p(), array_ranges_to_template_ranges(), create_init_common_param_for_arrays(), get_alignment(), hpfc_compute_align_constraints(), hpfc_compute_unicity_constraints(), and processors_dim_replicated_p().

Here is the caller graph for this function:

FindDistributionOfDim()

distribution FindDistributionOfDim	(	list	ldi,
		int	dim,
		int *	pdim
	)

Parameters

ldi	di
dim	im
pdim	dim

Definition at line 401 of file hpfc-util.c.

{
    list l = ldi;
    int i, procdim = 1;
 
    pips_assert("valid dimension", dim>=1 && dim<=(int)gen_length(ldi));
 
    for (i=1; i<dim; i++) 
    {
        if (!style_none_p(distribution_style(DISTRIBUTION(CAR(l)))))
            procdim++;
        POP(l);
    }
 
    (*pdim) = procdim;
    return(DISTRIBUTION(CAR(l)));
}

References CAR, DISTRIBUTION, distribution_style, gen_length(), pips_assert, POP, and style_none_p.

Referenced by ComputeNewSizeOfIthDimension(), create_init_common_param_for_arrays(), DistributionParameterOfArrayDim(), expr_compute_local_index(), get_distribution(), ith_dim_distributed_p(), ith_dim_overlapable_p(), and processor_number().

Here is the call graph for this function:

Here is the caller graph for this function:

FindDistributionOfProcessorDim()

distribution FindDistributionOfProcessorDim	(	list	ldi,
		int	dim,
		int *	tdim
	)

Parameters

ldi	di
dim	im
tdim	dim

Definition at line 421 of file hpfc-util.c.

{
    int i = 1, procdim = 0;
    
    MAP(DISTRIBUTION, d,
    {
        if (!style_none_p(distribution_style(d)))
            procdim++;
        
        if (procdim==dim)
        {
            (*tdim) = i;
            return(d);
        }
        
        i++;
    },
        ldi);
 
    pips_internal_error("dimension %d not found", dim);
 
    return(distribution_undefined);
}    

References DISTRIBUTION, distribution_style, distribution_undefined, MAP, pips_internal_error, and style_none_p.

Referenced by array_distribution_similar_p(), hpfc_compute_distribute_constraints(), processors_dim_replicated_p(), and template_ranges_to_processors_ranges().

Here is the caller graph for this function:

FindRefToDistArray()

list FindRefToDistArray

(

void *

obj

)

Parameters

obj

bj

Definition at line 282 of file hpfc-util.c.

{
    list result = NIL, saved = found_syntaxes;
    found_syntaxes = NIL;
    gen_multi_recurse(obj,
                      syntax_domain,
                      gen_true,
                      FindRefToDistArray_syntax_rewrite, NULL);
 
    result = found_syntaxes, found_syntaxes = saved;
 
    return result;
}

References FindRefToDistArray_syntax_rewrite(), found_syntaxes, gen_multi_recurse(), gen_true(), NIL, and syntax_domain.

Referenced by FindRefToDistArrayFromList(), FindRefToDistArrayInStatement_call_filter(), FindRefToDistArrayInStatement_expression_filter(), generate_c1_alpha(), and ref_to_dist_array_p().

Here is the call graph for this function:

Here is the caller graph for this function:

FindRefToDistArray_syntax_rewrite()

static void FindRefToDistArray_syntax_rewrite ( syntax  s )

static

Definition at line 272 of file hpfc-util.c.

{
    if (syntax_reference_p(s))
        if (array_distributed_p
            (reference_variable(syntax_reference(s))))
            found_syntaxes = 
                CONS(SYNTAX, s, found_syntaxes);
}

References array_distributed_p(), CONS, found_syntaxes, reference_variable, SYNTAX, syntax_reference, and syntax_reference_p.

Referenced by FindRefToDistArray().

Here is the call graph for this function:

Here is the caller graph for this function:

FindRefToDistArrayFromList()

list FindRefToDistArrayFromList

(

list

lexpr

)

FindRefToDistArrayFromList.

these functions compute the list of syntax that are references to a distributed variable.

Parameters

lexpr

expr

Definition at line 262 of file hpfc-util.c.

{
    list l=NIL;
    MAP(EXPRESSION, e,{l=gen_nconc(FindRefToDistArray(e),l);},lexpr);
    return(l);
}

References EXPRESSION, FindRefToDistArray(), gen_nconc(), MAP, and NIL.

Referenced by generate_c1_beta().

Here is the call graph for this function:

Here is the caller graph for this function:

get_alignment()

void get_alignment	(	entity	array,
		int	dim,
		int *	ptdim,
		int *	pa,
		int *	pb
	)

---

a nicer interface to extract the needed information. FC 29/03/94

replication

Parameters

array	rray
dim	im
ptdim	tdim
pa	a
pb	b

Definition at line 606 of file hpfc-util.c.

{ 
    align al = load_hpf_alignment(array);
    alignment a;
    
    pips_assert("distributed array", array_distributed_p(array));
    
    *ptdim = template_dimension_of_array_dimension(array, dim);
 
    if (*ptdim==-1) /* replication */
    {
        *pa=0, *pb=0;
        return;
    }
 
    a = FindAlignmentOfTemplateDim(align_alignment(al), *ptdim);
 
    if (a==alignment_undefined)
    {
        pips_assert("not aligned", *ptdim==0);
        *pa = 0; *pb = 0;
    }
    else
    {
        pips_assert("aligned", *ptdim>=1);
        *pa = HpfcExpressionToInt(alignment_rate(a));
        *pb = HpfcExpressionToInt(alignment_constant(a));
    }
}

References align_alignment, alignment_constant, alignment_rate, alignment_undefined, array, array_distributed_p(), FindAlignmentOfTemplateDim(), HpfcExpressionToInt(), load_hpf_alignment(), pips_assert, and template_dimension_of_array_dimension().

Referenced by alignments_compatible_p(), and hpfc_compute_entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

get_distribution()

void get_distribution	(	entity	template,
		int	dim,
		int *	ppdim,
		int *	pn
	)

Parameters

template	emplate
dim	im
ppdim	pdim
pn	n

Definition at line 638 of file hpfc-util.c.

{
    distribution
        d = FindDistributionOfDim
            (distribute_distribution(load_hpf_distribution(template)), 
                                     dim, ppdim);
 
    *pn = (distribution_undefined_p(d) ?
           -1: HpfcExpressionToInt(distribution_parameter(d)));
}

References distribute_distribution, distribution_parameter, distribution_undefined_p, FindDistributionOfDim(), HpfcExpressionToInt(), and load_hpf_distribution().

Referenced by hpfc_compute_entity_to_new_declaration(), and processor_dimension_of_template_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

get_entity_dimensions()

void get_entity_dimensions	(	entity	e,
		int	dim,
		int *	plow,
		int *	pup
	)

Parameters

dim	im
plow	low
pup	up

Definition at line 651 of file hpfc-util.c.

{
    dimension d = dimension_undefined;
 
    pips_assert("valid variable and dimension",
                entity_variable_p(e) && dim>0 && dim<=7);
 
    d = entity_ith_dimension(e, dim),
    *plow = ExpressionToInt(dimension_lower(d)),
    *pup = ExpressionToInt(dimension_upper(d));
}

References dimension_lower, dimension_undefined, dimension_upper, entity_ith_dimension(), entity_variable_p, ExpressionToInt(), and pips_assert.

Referenced by conformant_entities_p(), extract_the_align(), full_linearization(), hpfc_compute_entity_to_new_declaration(), hpfc_compute_lid(), partial_linearization(), and safe_static_domain_bound().

Here is the call graph for this function:

Here is the caller graph for this function:

global_array_cell_to_local_array_cell()

int global_array_cell_to_local_array_cell	(	entity	array,
		int	dim,
		int	acell
	)

int global_array_cell_to_local_array_cell(array, dim, acell)

??? not enough general a function

Parameters

array	rray
dim	im
acell	cell

Definition at line 550 of file hpfc-util.c.

{
    alignment a = FindArrayDimAlignmentOfArray(array, dim);
    int rate, constant;
 
    pips_assert("aligned", a!=alignment_undefined);
 
    rate     = HpfcExpressionToInt(alignment_rate(a));
    constant = HpfcExpressionToInt(alignment_constant(a));
 
    return template_cell_local_mapping(array, dim, rate*acell+constant);
}

References alignment_constant, alignment_rate, alignment_undefined, array, FindArrayDimAlignmentOfArray, HpfcExpressionToInt(), pips_assert, and template_cell_local_mapping().

Referenced by shape_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_util_error_handler()

void hpfc_util_error_handler

(

void

)

removes IF (.TRUE.) THEN and DO X=n, n

Definition at line 785 of file hpfc-util.c.

{
    error_reset_current_stmt_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

HpfcExpressionToInt()

int HpfcExpressionToInt

(

expression

e

)

HpfcExpressionToInt(e)

uses the normalized value if possible.

just to avoid a gcc warning

Definition at line 569 of file hpfc-util.c.

{
    normalized n = expression_normalized(e);
    intptr_t val = 0;
 
    ifdebug(8) print_expression(e);
 
    if ((n!=normalized_undefined) && (normalized_linear_p(n)))
    {
        Pvecteur v = normalized_linear(n);
        int s = vect_size(v), val;
        Value vval = vect_coeff(TCST, v);
 
        val = VALUE_TO_INT(vval);
        if (s==0) return 0;
        if ((s==1) && (val!=0)) return val;
    }
    
    /*
    if (expression_integer_constant_p(e))
        return ExpressionToInt(e);
    */
    if(expression_integer_value(e, &val))
        return val;
    else
        pips_internal_error("can't return anything, sorry");
 
    return -1; /* just to avoid a gcc warning */
}

References expression_integer_value(), expression_normalized, ifdebug, intptr_t, normalized_linear, normalized_linear_p, normalized_undefined, pips_internal_error, print_expression(), TCST, VALUE_TO_INT, vect_coeff(), and vect_size().

Referenced by align_check(), array_access_to_array_ranges(), array_ranges_to_template_ranges(), complementary_range(), compute_receive_content(), compute_receive_domain(), ComputeNewSizeOfIthDimension(), create_init_common_param_for_arrays(), create_init_common_param_for_processors(), create_init_common_param_for_templates(), create_parameters_h(), DistributionParameterOfArrayDim(), expr_compute_local_index(), generate_one_message(), get_alignment(), get_distribution(), get_ith_dim_new_declaration(), global_array_cell_to_local_array_cell(), handle_set_directive(), hpfc_compute_align_constraints(), hpfc_compute_distribute_constraints(), hpfc_compute_unicity_constraints(), loop_filter(), make_guard_expression(), NormalizeOneTemplateDistribution(), overlap_redefine_expression(), processor_number(), same_alignment_p(), shape_one_message(), simple_indices_p(), template_cell_local_mapping(), and template_ranges_to_processors_ranges().

Here is the call graph for this function:

Here is the caller graph for this function:

ith_dim_distributed_p()

bool ith_dim_distributed_p	(	entity	array,
		int	i,
		int *	pprocdim
	)

whether a dimension is distributed or not.

Parameters

array	rray
pprocdim	procdim

Definition at line 160 of file hpfc-util.c.

{
    align       al = load_hpf_alignment(array);
    list       lal = align_alignment(al);
    alignment  alt = FindAlignmentOfDim(lal, i);
    entity template = align_template(al);
    distribute dis = load_hpf_distribution(template);
    list ld = distribute_distribution(dis);
    distribution d;
 
    if (alignment_undefined_p(alt)) return(false);
    d = FindDistributionOfDim(ld, alignment_templatedim(alt), pprocdim);
    return(!style_none_p(distribution_style(d)));
}

References align_alignment, align_template, alignment_templatedim, alignment_undefined_p, array, distribute_distribution, distribution_style, FindAlignmentOfDim(), FindDistributionOfDim(), load_hpf_alignment(), load_hpf_distribution(), and style_none_p.

Referenced by align_check(), atomize_one_message(), compute_receive_content(), generate_optimized_code_for_loop_nest(), loop_flt(), NewDeclarationOfDistributedArray(), number_of_distributed_dimensions(), shape_one_message(), simple_indices_p(), and subarray_shift_assignment_p().

Here is the call graph for this function:

Here is the caller graph for this function:

ith_dim_overlapable_p()

bool ith_dim_overlapable_p	(	entity	array,
		int	i
	)

Parameters

array

rray

Definition at line 178 of file hpfc-util.c.

{
    align       al = load_hpf_alignment(array);
    list       lal = align_alignment(al);
    alignment  alt = FindAlignmentOfDim(lal, i);
    entity template = align_template(al);
    distribute dis = load_hpf_distribution(template);
    list ld = distribute_distribution(dis);
    distribution d;
    int p;
 
    if (alignment_undefined_p(alt)) return false;
    d = FindDistributionOfDim(ld, alignment_templatedim(alt), &p);
 
    return style_block_p(distribution_style(d));
}

References align_alignment, align_template, alignment_templatedim, alignment_undefined_p, array, distribute_distribution, distribution_style, FindAlignmentOfDim(), FindDistributionOfDim(), load_hpf_alignment(), load_hpf_distribution(), and style_block_p.

Referenced by add_bound_arguments(), caller_list_of_bounds(), create_parameters_h(), and declaration_with_overlaps().

Here is the call graph for this function:

Here is the caller graph for this function:

ith_dim_replicated_p()

bool ith_dim_replicated_p	(	_UNUSED_ entity	template,
		int	i,
		list	la,
		distribution	dist
	)

bool ith_dim_replicated_p(template, i, la, dist)

true if template dimension i distributed with dist leads to a replication for array align al.

select the relevent alignment if exists. could be some kind of gen_find_if()...

Definition at line 125 of file hpfc-util.c.

{
    if (style_none_p(distribution_style(dist))) return false;
 
    /* select the relevent alignment if exists.
     * could be some kind of gen_find_if()...
     */
    MAP(ALIGNMENT, a, if (alignment_templatedim(a)==i) return false, la);
 
    return true;
}

References ALIGNMENT, alignment_templatedim, distribution_style, MAP, and style_none_p.

Referenced by replicated_p().

Here is the caller graph for this function:

kill_statement_number_and_ordering()

void kill_statement_number_and_ordering

(

statement

s

)

Definition at line 232 of file hpfc-util.c.

{
    gen_recurse(s, statement_domain, gen_true, stmt_rwt);
}

References gen_recurse, gen_true(), statement_domain, and stmt_rwt().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_rewrite()

static void loop_rewrite ( loop  l )

static

instruction i = statement_instruction(s);

Do not forget to move forbidden information associated with block:

free_instruction(i);

??? memory leak, cores on AIX

Definition at line 822 of file hpfc-util.c.

{
    range r = loop_range(l);
    if (expression_equal_p(range_lower(r), range_upper(r)))
    {
        statement s = current_stmt_head();
        /* instruction i = statement_instruction(s); */
        pips_debug(5, "loop on %s simplified\n", entity_name(loop_index(l)));
 
        statement_instruction(s) = 
            make_instruction_block(
              CONS(STATEMENT, make_assign_statement
                   (entity_to_expression(loop_index(l)),
                    copy_expression(range_lower(r))),
              CONS(STATEMENT, loop_body(l), NIL)));
        /* Do not forget to move forbidden information associated with
           block: */
        fix_sequence_statement_attributes(s);
    
        loop_body(l) = statement_undefined;
        /* free_instruction(i); */ /* ??? memory leak, cores on AIX */
    }
}

References CONS, copy_expression(), current_stmt_head, entity_name, entity_to_expression(), expression_equal_p(), fix_sequence_statement_attributes(), loop_body, loop_index, loop_range, make_assign_statement(), make_instruction_block(), NIL, pips_debug, range_lower, range_upper, STATEMENT, statement_instruction, and statement_undefined.

Referenced by statement_structural_cleaning().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeStatementLike()

statement MakeStatementLike	(	statement	stat,
		int	the_tag
	)

creates a new statement for the given module that looks like the stat one, i.e.

same comment, same label, and so on. The goto table is updated. The instruction is also created. (is that really a good idea?)

Parameters

stat	tat
the_tag	he_tag

Definition at line 203 of file hpfc-util.c.

{
    void* x = loop_undefined;
    string c = statement_comments(stat);
    statement new_s;
 
    if (the_tag==is_instruction_sequence)
        x = make_sequence(NIL);
 
 
    new_s = make_statement(statement_label(stat),
                           STATEMENT_NUMBER_UNDEFINED,
                           STATEMENT_ORDERING_UNDEFINED,
                           string_undefined_p(c)? c: strdup(c),
                           make_instruction(the_tag, x),NIL,NULL,
                           copy_extensions (statement_extensions(stat)), make_synchronization_none());
    fix_statement_attributes_if_sequence(new_s);
    return new_s;
}

References copy_extensions(), fix_statement_attributes_if_sequence(), is_instruction_sequence, loop_undefined, make_instruction(), make_sequence(), make_statement(), make_synchronization_none(), NIL, statement_comments, statement_extensions, statement_label, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, strdup(), string_undefined_p, and x.

Referenced by hpf_compile_block(), hpf_compile_call(), hpf_compile_parallel_loop(), hpf_compile_sequential_loop(), hpf_compile_test(), and hpf_compile_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

processor_dimension_of_template_dimension()

int processor_dimension_of_template_dimension	(	entity	template,
		int	dim
	)

Parameters

template	emplate
dim	im

Definition at line 462 of file hpfc-util.c.

{
    int pdim = 0, n;
    if (dim>=0) get_distribution(template, dim, &pdim, &n);
    return pdim;
}

References get_distribution().

Here is the call graph for this function:

processor_number()

int processor_number	(	entity	template,
		int	tdim,
		int	tcell,
		int *	pprocdim
	)

int processor_number(template, tdim, tcell, pprocdim)

the processor number of a template cell, on dimension *pprocdim template dimension, template cell

just to avoid a gcc warning

Parameters

template	emplate
tdim	dim
tcell	cell
pprocdim	procdim

Definition at line 492 of file hpfc-util.c.

{
    distribute d = load_hpf_distribution(template);
    list ld = distribute_distribution(d);
    entity procs = distribute_processors(d);
    distribution di = FindDistributionOfDim(ld, tdim, pprocdim);
    style st = distribution_style(di);
    int n, tmin, pmin, psiz;
 
    if (style_none_p(st))
    {
        *pprocdim = -1;
        return -1;
    }
 
    tmin = HpfcExpressionToInt
        (dimension_lower(FindIthDimension(template, tdim)));
    pmin = HpfcExpressionToInt
        (dimension_lower(FindIthDimension(procs, *pprocdim)));
    psiz = SizeOfIthDimension(procs, *pprocdim);
    n    = HpfcExpressionToInt(distribution_parameter(di));
 
    if (style_block_p(st))
        return ((tcell-tmin)/n)+pmin;
 
    if (style_cyclic_p(st))
        return (((tcell-tmin)/n)%psiz)+pmin;
 
    *pprocdim = -1; /* just to avoid a gcc warning */
    return -1; 
}    

References dimension_lower, distribute_distribution, distribute_processors, distribution_parameter, distribution_style, FindDistributionOfDim(), FindIthDimension(), HpfcExpressionToInt(), load_hpf_distribution(), SizeOfIthDimension(), style_block_p, style_cyclic_p, and style_none_p.

Referenced by aligned_p(), on_same_proc_p(), and template_ranges_to_processors_ranges().

Here is the call graph for this function:

Here is the caller graph for this function:

processors_dim_replicated_p()

bool processors_dim_replicated_p	(	_UNUSED_ entity	p,
		entity	a,
		int	i
	)

true if array a is replicated on processors p i-th dimension.

Definition at line 143 of file hpfc-util.c.

{
    int tdim;
    align al = load_hpf_alignment(a);
    entity t = align_template(al);
    distribute d = load_hpf_distribution(t);
    distribution di =
        FindDistributionOfProcessorDim(distribute_distribution(d), i, &tdim);
    alignment ali = 
        FindAlignmentOfTemplateDim(align_alignment(al), tdim);
 
    return(!style_none_p(distribution_style(di)) &&
           alignment_undefined_p(ali));
}

References align_alignment, align_template, alignment_undefined_p, distribute_distribution, distribution_style, FindAlignmentOfTemplateDim(), FindDistributionOfProcessorDim(), load_hpf_alignment(), load_hpf_distribution(), and style_none_p.

Referenced by hpfc_broadcast_buffers(), hpfc_compute_lid(), partial_linearization(), and remapping_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_to_dist_array_p()

bool ref_to_dist_array_p

(

void *

obj

)

this file describe a few functions usefull to the compiler to manage the hpfc data structures.

hpfc-util.c

Fabien Coelho, May 1993. Predicates true if there is a reference to a distributed array within obj

??? not very intelligent, should use the regions, the problem is that I should normalize the code before the pips analysis...

Parameters

obj

bj

Definition at line 48 of file hpfc-util.c.

{
    list l = FindRefToDistArray(obj);
    bool b = (l!=NIL);
 
    gen_free_list(l); return(b);
}

References FindRefToDistArray(), gen_free_list(), and NIL.

Referenced by call_filter(), hpf_compile_call(), and test_atomization().

Here is the call graph for this function:

Here is the caller graph for this function:

references_aligned_p()

bool references_aligned_p	(	reference	r1,
		reference	r2
	)

of expression

both references must be aligned to the same template and be of the same arity.

Parameters

r1	1
r2	2

Definition at line 726 of file hpfc-util.c.

{
    entity e1 = reference_variable(r1),
           e2 = reference_variable(r2);
    list /* of expression */ le1 = reference_indices(r1),
                             le2 = reference_indices(r2);
    int dim1 = 1, dim2;
    entity index;
    align a1, a2;
 
    if (!array_distributed_p(e1) || !array_distributed_p(e2))
    {
        XDEBUG("not distributed"); return false;
    }
 
    a1 = load_hpf_alignment(e1);
    a2 = load_hpf_alignment(e2);
 
    /* both references must be aligned to the same template
     * and be of the same arity.
     */
    if (align_template(a1)!=align_template(a2))
    {
        XDEBUG("template is different"); return false;
    }
 
    if (gen_length(le1)!=gen_length(le2))
    {
        XDEBUG("arities are different"); return false;
    }
    
    MAP(EXPRESSION, ind, 
    {
        if (!expression_reference_p(ind))
            return false;
 
        index = reference_variable(syntax_reference(expression_syntax(ind)));
        dim2 = expression_number_for_index(index, le2);
 
        if (!alignments_compatible_p(e1, dim1, e2, dim2))
        {
            XDEBUG("alignments are incompatible"); return false;
        }
        
        dim1++;
    },
        le1);
 
    XDEBUG("aligned!"); return true;
}

References align_template, alignments_compatible_p(), array_distributed_p(), EXPRESSION, expression_number_for_index(), expression_reference_p(), expression_syntax, gen_length(), load_hpf_alignment(), MAP, reference_indices, reference_variable, syntax_reference, and XDEBUG.

Referenced by full_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

replicated_p()

bool replicated_p

(

entity

e

)

replicated_p

check whether the distributed array e is replicated or not.

Definition at line 96 of file hpfc-util.c.

{
    int i, ntdim;
    align a;
    list la, ld;
    entity template;
    distribute d;
 
    pips_assert("distributed array", array_distributed_p(e));
 
    a = load_hpf_alignment(e);
    la = align_alignment(a);    
    template = align_template(a);
    d = load_hpf_distribution(template);
    ld = distribute_distribution(d);
    ntdim = NumberOfDimension(template);
 
    for(i=1; i<=ntdim; i++, POP(ld))
        if (ith_dim_replicated_p(template, i, la, DISTRIBUTION(CAR(ld))))
            return true;
 
    return false;
}

References align_alignment, align_template, array_distributed_p(), CAR, distribute_distribution, DISTRIBUTION, ith_dim_replicated_p(), load_hpf_alignment(), load_hpf_distribution(), NumberOfDimension(), pips_assert, and POP.

Referenced by generate_update_distributed_value_from_host(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), hpfc_broadcast_buffers(), if_different_pe_and_not_twin(), io_efficient_compile(), Overlap_Analysis(), st_receive_from(), st_send_to_computer_if_necessary(), and st_send_to_host_and_nodes().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_structural_cleaning()

void statement_structural_cleaning

(

statement

s

)

Definition at line 847 of file hpfc-util.c.

{
    make_current_stmt_stack();
 
    gen_multi_recurse(s,
        statement_domain, current_stmt_filter, current_stmt_rewrite,
        test_domain,      gen_true,            test_rewrite,
        loop_domain,      gen_true,            loop_rewrite,
                      NULL);  
  
    free_current_stmt_stack();
}

References gen_multi_recurse(), gen_true(), loop_domain, loop_rewrite(), statement_domain, test_domain, and test_rewrite().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

stmt_rwt()

static void stmt_rwt ( statement  s )

static

Definition at line 225 of file hpfc-util.c.

{
    statement_number(s) = STATEMENT_NUMBER_UNDEFINED;
    statement_ordering(s) = STATEMENT_ORDERING_UNDEFINED;
}

References statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, and STATEMENT_ORDERING_UNDEFINED.

Referenced by kill_statement_number_and_ordering().

Here is the caller graph for this function:

template_cell_local_mapping()

int template_cell_local_mapping	(	entity	array,
		int	dim,
		int	tc
	)

int template_cell_local_mapping(array, dim, tc)

??? should check that it is indeed block distributed ! or should implement all the formulas...

Parameters

array	rray
dim	im
tc	c

Definition at line 532 of file hpfc-util.c.

{
    alignment a = FindArrayDimAlignmentOfArray(array, dim);
    int p, tmin, n = DistributionParameterOfArrayDim(array, dim, &p);
    dimension d = FindIthDimension(array_to_template(array), 
                                   alignment_templatedim(a));
 
    tmin = HpfcExpressionToInt(dimension_lower(d));
 
    return (tc-tmin)%n+1;
}

References alignment_templatedim, array, array_to_template, dimension_lower, DistributionParameterOfArrayDim(), FindArrayDimAlignmentOfArray, FindIthDimension(), HpfcExpressionToInt(), and tc.

Referenced by generate_one_message(), global_array_cell_to_local_array_cell(), and update_indices_for_local_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

template_dimension_of_array_dimension()

int template_dimension_of_array_dimension	(	entity	array,
		int	dim
	)

Parameters

array	rray
dim	im

Definition at line 448 of file hpfc-util.c.

{
    align a;
    alignment al;
 
    a = load_hpf_alignment(array);
    al = FindAlignmentOfDim(align_alignment(a), dim);
    
    return (al==alignment_undefined) ? -1 : alignment_templatedim(al);
}

References align_alignment, alignment_templatedim, alignment_undefined, array, FindAlignmentOfDim(), and load_hpf_alignment().

Referenced by aligned_p(), get_alignment(), and message_manageable_p().

Here is the call graph for this function:

Here is the caller graph for this function:

test_rewrite()

static void test_rewrite ( test  t )

static

instruction i = statement_instruction(s);

Fix attributes if it is a sequence:

free_instruction(i);

???

instruction i = statement_instruction(s);

Fix attributes if it is a sequence:

free_instruction(i);

???

Definition at line 790 of file hpfc-util.c.

{
    entity e = expression_to_entity(test_condition(t));
 
    if (ENTITY_TRUE_P(e))
    {
        statement s = current_stmt_head();
        /* instruction i = statement_instruction(s); */
        pips_debug(5, "true test simplified\n");
 
        statement_instruction(s) = statement_instruction(test_true(t));
        /* Fix attributes if it is a sequence: */
        fix_statement_attributes_if_sequence(s);
 
        statement_instruction(test_true(t)) = instruction_undefined;
        /* free_instruction(i); */ /* ??? */
    }
    else if (ENTITY_FALSE_P(e))
    {   
        statement s = current_stmt_head();
        /* instruction i = statement_instruction(s); */
        pips_debug(5, "false test simplified\n");
 
        statement_instruction(s) = statement_instruction(test_false(t));
        /* Fix attributes if it is a sequence: */
        fix_statement_attributes_if_sequence(s);
 
        statement_instruction(test_false(t)) = instruction_undefined;
        /* free_instruction(i); */ /* ??? */
    }
}

References current_stmt_head, ENTITY_FALSE_P, ENTITY_TRUE_P, expression_to_entity(), fix_statement_attributes_if_sequence(), instruction_undefined, pips_debug, statement_instruction, test_condition, test_false, and test_true.

Referenced by statement_structural_cleaning().

Here is the call graph for this function:

Here is the caller graph for this function:

written_effect_p()

bool written_effect_p	(	entity	var,
		list	le
	)

written_effects_to_dist_arrays_p

Parameters

var	ar
le	e

Definition at line 58 of file hpfc-util.c.

{
  FOREACH(EFFECT, e, le)
    {
      if(store_effect_p(e)) {
        if (reference_variable(effect_any_reference(e))==var &&
            action_write_p(effect_action(e)))
            return true;
      }
    }
 
    return false;
}

References action_write_p, EFFECT, effect_action, effect_any_reference, FOREACH, reference_variable, and store_effect_p().

Referenced by locally_constant_vector_p().

Here is the call graph for this function:

Here is the caller graph for this function:

written_effects_to_dist_arrays_p()

bool written_effects_to_dist_arrays_p

(

expression

expr

)

Parameters

expr

xpr

Definition at line 73 of file hpfc-util.c.

{
    list l, leffects_to_dist_arrays = DistArraysEffects(expr);
 
    // FI: looks like a FOREACH to me...
    for(l=leffects_to_dist_arrays; !ENDP(l); POP(l))
      if(store_effect_p(EFFECT(CAR(l)))) {
        if  (action_write_p(effect_action(EFFECT(CAR(l)))))
        {
            gen_free_list(leffects_to_dist_arrays);
            return true;
        }
      }
 
    gen_free_list(leffects_to_dist_arrays);
    return false;
}

References action_write_p, CAR, DistArraysEffects(), EFFECT, effect_action, ENDP, gen_free_list(), POP, and store_effect_p().

Here is the call graph for this function:

Variable Documentation

found_syntaxes

list found_syntaxes = NIL

static

Definition at line 270 of file hpfc-util.c.

Referenced by FindRefToDistArray(), and FindRefToDistArray_syntax_rewrite().