dynamic.c File Reference

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

Include dependency graph for dynamic.c:

Go to the source code of this file.

Macros
#define	RETAL(msg, res)    { pips_debug(7, "%d because %s\n", res, msg); return res;}
#define	RET(msg, what)    { pips_debug(6, "not similar because %s\n", msg); return what;}
#define	ret(why, what)    { pips_debug(9, "ret %d because %s\n", what, why); return what; }
	true if not a remapping for old. More...
#define	elst_ifdef(what, name, s)

Functions
entity	safe_load_primary_entity (entity e)
	HPFC module by Fabien COELHO. More...
bool	same_primary_entity_p (entity e1, entity e2)
void	init_dynamic_status ()
	DYNAMIC STATUS management. More...
void	reset_dynamic_status ()
dynamic_status	get_dynamic_status ()
void	set_dynamic_status (dynamic_status d)
void	close_dynamic_status ()
void	set_entity_as_dynamic (entity e)
	a new dynamic entity is stored. More...
static void	add_dynamic_synonym (entity new_e, entity e)
	what: new_e is stored as a synonym of e. More...
void	set_similar_mappings_for_updates (void)
static entity	new_synonym (entity e)
	builds a synonym for entity e. More...
static void	check_for_similarity (entity a, list others)
void	hpfc_check_for_similarities (list le)
	check all dynamic arrays for some similars... More...
static entity	new_synonym_array (entity a, align al)
	builds a new synonym for array a, the alignment of which will be al. More...
static entity	new_synonym_template (entity t, distribute di)
	builds a new synonym for template t, the distribution of which will be di. More...
static bool	conformant_entities_p (entity e1, entity e2)
static bool	same_distribute_p (distribute d1, distribute d2)
	comparison of DISTRIBUTE. More...
static bool	same_alignment_in_list_p (alignment a, list l)
	comparison of ALIGN. More...
bool	conformant_templates_p (entity t1, entity t2)
static bool	same_align_p (align a1, align a2)
entity	array_synonym_aligned_as (entity array, align a)
	entity array_synonym_aligned_as(array, a) entity array; align a; More...
align	new_align_with_template (align a, entity t)
entity	template_synonym_distributed_as (entity temp, distribute d)
	what: finds or creates a new entity distributed as needed. More...
static bool	same_distribution_p (distribution d1, distribution d2)
	array_distribution_similar_p More...
static bool	same_alignment_p (entity e1, entity t1, alignment a1, entity e2, entity t2, alignment a2)
bool	array_distribution_similar_p (entity a1, entity a2)
bool	hpfc_call_with_distributed_args_p (call c)
	whether call c inplies a distributed argument More...
static list	add_once_to_renaming_list (list l, entity o, entity n)
	of renaming More...
void	hpfc_translate_call_with_distributed_args (statement s, call c)
	??? only simple calls are handled. More...
void	init_dynamic_locals ()
	DYNAMIC LOCAL DATA. More...
void	close_dynamic_locals ()
static void	lazy_initialize_for_statement (statement s)
	starting point More...
static void	add_as_a_closing_statement (statement s)
static void	add_as_a_used_variable (entity e)
void	add_as_a_used_dynamic_to_statement (statement s, entity e)
static void	add_as_a_modified_variable (entity e)
static void	add_alive_synonym (statement s, entity a)
static void	ref_rwt (reference r)
static void	simple_switch_old_to_new (statement s)
static bool	rename_directive_p (entity f)
static bool	continue_propagation_p (statement s)
void	propagate_synonym (statement s, entity old, entity new, bool is_array)
static void	initialize_reaching_propagation (statement s)
	for statement s More...
static void	remove_not_remapped_leavings (statement s)
static void	initialize_maybeuseful_mappings (statement s)
	must be called after useless leaving mappings removal More...
static void	reinitialize_reaching_mappings (statement s)
static list	propagation_on_remapping_graph (statement s, list ls, entities(*built)(statement), entities(*condition)(statement), bool local, bool forward)
	more options, such as may or must? More...
static list	propagate_used_arrays (statement s, list ls)
	of statements More...
static list	propagate_maybeuseful_mappings (statement s, list ls)
	of statements More...
static void	remove_from_entities (entity primary, entities es)
static void	remove_unused_remappings (statement s)
static void	regenerate_renamings (statement s)
	regenerate the renaming structures after the optimizations performed on the remapping graph. More...
static list	list_of_remapping_statements ()
	of statements More...
static void	print_control_ordering (control c)
	functions used for debug. More...
static void	dump_remapping_graph_info (statement s)
static void	dump_remapping_graph (string when, list ls)
void	dump_current_remapping_graph (string when)
void	simplify_remapping_graph (void)
	void simplify_remapping_graph() More...
list	alive_arrays (statement s, entity t)
	what: returns the list of alive arrays for statement s and template t. More...
statement	generate_copy_loop_nest (entity src, entity trg)
	statement generate_copy_loop_nest(src, trg) entity src, trg; More...

Variables
bool(*	dynamic_entity_p )(entity) = bound_dynamic_hpf_p
	as expected, true if entity e is dynamic. More...
static entity	old_variable = entity_undefined
	void propagate_synonym(s, old, new) statement s; entity old, new; More...
static entity	new_variable = entity_undefined
	entity to be replaced, the primary? More...
static bool	array_propagation
	replacement More...
static bool	array_used
	true if an array is propagated, false if template More...
static bool	array_modified
	true if the array was actually used More...
static statement	initial_statement = statement_undefined
	true if the array may be modified... More...

Macro Definition Documentation

elst_ifdef

#define elst_ifdef	(		what,
			name,
			s
	)

Value:

 if (bound_##name##_p(s)){DEBUG_ELST(1, what, entities_list(load_##name(s)));}\
 else pips_debug(1, "no " what "\n");

Definition at line 1406 of file dynamic.c.

RET

#define RET	(		msg,
			what
	)		{ pips_debug(6, "not similar because %s\n", msg); return what;}

Definition at line 574 of file dynamic.c.

ret

#define ret	(		why,
			what
	)		{ pips_debug(9, "ret %d because %s\n", what, why); return what; }

true if not a remapping for old.

if it is a remapping, operates the switch.

Definition at line 986 of file dynamic.c.

RETAL

#define RETAL	(		msg,
			res
	)		{ pips_debug(7, "%d because %s\n", res, msg); return res;}

Definition at line 531 of file dynamic.c.

Function Documentation

add_alive_synonym()

static void add_alive_synonym ( statement  s, entity  a  )

static

lazy initialization

Definition at line 916 of file dynamic.c.

{
    entities es;
 
    /*   lazy initialization 
     */
    if (!bound_alive_synonym_p(s))
        store_alive_synonym(s, make_entities(NIL));
 
    es = load_alive_synonym(s);
    entities_list(es) = gen_once(a, entities_list(es));
}

References entities_list, gen_once(), make_entities(), and NIL.

Referenced by continue_propagation_p().

Here is the call graph for this function:

Here is the caller graph for this function:

add_as_a_closing_statement()

static void add_as_a_closing_statement ( statement  s )

static

Definition at line 882 of file dynamic.c.

{
    control 
        c = load_remapping_graph(initial_statement),
        n = (lazy_initialize_for_statement(s), load_remapping_graph(s));
 
    what_stat_debug(6, s);
 
    control_successors(c) = 
        gen_once(load_remapping_graph(s), control_successors(c));
    control_predecessors(n) = 
        gen_once(load_remapping_graph(initial_statement),
                 control_predecessors(n));
}

References control_predecessors, control_successors, gen_once(), initial_statement, lazy_initialize_for_statement(), and what_stat_debug.

Referenced by continue_propagation_p().

Here is the call graph for this function:

Here is the caller graph for this function:

add_as_a_modified_variable()

static void add_as_a_modified_variable ( entity  e )

static

Definition at line 910 of file dynamic.c.

{
    entities es = load_modified_dynamics(initial_statement);
    entities_list(es) = gen_once(load_primary_entity(e), entities_list(es));
}

References entities_list, gen_once(), initial_statement, and load_primary_entity().

Referenced by propagate_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

add_as_a_used_dynamic_to_statement()

void add_as_a_used_dynamic_to_statement	(	statement	s,
		entity	e
	)

Definition at line 904 of file dynamic.c.

{
    entities es = load_used_dynamics(s);
    entities_list(es) = gen_once(load_primary_entity(e), entities_list(es));
}

References entities_list, gen_once(), and load_primary_entity().

Referenced by initial_alignment().

Here is the call graph for this function:

Here is the caller graph for this function:

add_as_a_used_variable()

static void add_as_a_used_variable ( entity  e )

static

Definition at line 897 of file dynamic.c.

{
    entities es = load_used_dynamics(initial_statement);
    entities_list(es) = gen_once(load_primary_entity(e), entities_list(es));
}

References entities_list, gen_once(), initial_statement, and load_primary_entity().

Referenced by propagate_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

add_dynamic_synonym()

static void add_dynamic_synonym ( entity  new_e, entity  e  )

static

what: new_e is stored as a synonym of e.

Definition at line 149 of file dynamic.c.

{
    entities es = load_dynamic_hpf(e);
    pips_debug(3, "%s as %s synonyms\n", entity_name(new_e), entity_name(e));
    pips_assert("dynamicity", dynamic_entity_p(e) && !dynamic_entity_p(new_e));
    entities_list(es) = CONS(ENTITY, new_e, entities_list(es));
    store_dynamic_hpf(new_e, es);
    store_primary_entity(new_e, load_primary_entity(e));
}

References CONS, dynamic_entity_p, entities_list, ENTITY, entity_name, load_dynamic_hpf(), load_primary_entity(), pips_assert, pips_debug, store_dynamic_hpf(), and store_primary_entity().

Referenced by new_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

add_once_to_renaming_list()

static list add_once_to_renaming_list ( list  l, entity  o, entity  n  )

static

of renaming

Parameters

l	of renaming

Definition at line 665 of file dynamic.c.

{
    MAP(RENAMING, r,
    {
        if (renaming_old(r)==o)
        {
            pips_assert("same required mapping", renaming_new(r)==n);
            return l;
        }
    },
        l);
 
    return CONS(RENAMING, make_renaming(o, n), l);
}

References CONS, make_renaming(), MAP, pips_assert, RENAMING, renaming_new, and renaming_old.

Referenced by hpfc_translate_call_with_distributed_args().

Here is the call graph for this function:

Here is the caller graph for this function:

alive_arrays()

list alive_arrays	(	statement	s,
		entity	t
	)

what: returns the list of alive arrays for statement s and template t.

how: uses the alive_synonym, and computes the defaults. input: statement s and template t which are of interest. output: a list of entities which is allocated. side effects: none. of entities

of entities

to tag seen primaries.

??? well, it is not necessarily initialized, I guess...

first the alive list is scanned.

second the defaults are looked for. namely the primary entities.

Definition at line 1504 of file dynamic.c.

{
    list /* of entities */ l = NIL, lseens = NIL; /* to tag seen primaries. */
 
    pips_assert("template", entity_template_p(t) && primary_entity_p(t));
    pips_debug(7, "for template %s\n", entity_name(t));
 
    /* ??? well, it is not necessarily initialized, I guess...
     */
    if (!bound_alive_synonym_p(s))
        store_alive_synonym(s, make_entities(NIL));
 
    /*   first the alive list is scanned.
     */
    MAP(ENTITY, array,
    {
        entity ta = align_template(load_hpf_alignment(array));
 
        if (safe_load_primary_entity(ta)==t)
            l = CONS(ENTITY, array, l);
 
        pips_debug(8, "adding %s as alive\n", entity_name(array));
        
        lseens = CONS(ENTITY, load_primary_entity(array), lseens);
    },
        entities_list(load_alive_synonym(s)));
 
    /*   second the defaults are looked for. namely the primary entities.
     */
    MAP(ENTITY, array,
    {
        if (primary_entity_p(array) && !gen_in_list_p(array, lseens))
        {
            if (align_template(load_hpf_alignment(array))==t)
                l = CONS(ENTITY, array, l);
            
            pips_debug(8, "adding %s as default\n", entity_name(array));
        
            lseens = CONS(ENTITY, array, lseens);
        }
    },
        list_of_distributed_arrays());
 
    DEBUG_ELST(9, "seen arrays", lseens);
    gen_free_list(lseens);
 
    DEBUG_ELST(7, "returned alive arrays", l);
    return l;
}

References align_template, array, CONS, DEBUG_ELST, entities_list, ENTITY, entity_name, entity_template_p(), gen_free_list(), gen_in_list_p(), list_of_distributed_arrays(), load_hpf_alignment(), load_primary_entity(), make_entities(), MAP, NIL, pips_assert, pips_debug, primary_entity_p, and safe_load_primary_entity().

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

array_distribution_similar_p()

bool array_distribution_similar_p	(	entity	a1,
		entity	a2
	)

conformant processors ??? could assume that P(1:1,1:n) is conformant to P'(1:n)?

considering ith dim of proc

conformant distributions

if the size is 1, whatever the distribution it is ok!

conformant alignments for that pe dim !!! the HPF mapping "semantics" insure that the corresponding dimension is distributed!

Parameters

a1	1
a2	2

Definition at line 578 of file dynamic.c.

{
    align 
        al1 = load_hpf_alignment(a1),
        al2 = load_hpf_alignment(a2);
    entity 
        t1 = align_template(al1),
        t2 = align_template(al2);
    distribute 
        d1 = load_hpf_distribution(t1),
        d2 = load_hpf_distribution(t2);
    entity
        p1 = distribute_processors(d1),
        p2 = distribute_processors(d2);
    int i, td1, td2,
        ndimdist = NumberOfDimension(p1);
 
    pips_assert("same primary", 
                load_primary_entity(a1)==load_primary_entity(a2));
 
    pips_debug(6, "comparing %s and %s\n", entity_name(a1), entity_name(a2));
 
    /* conformant processors 
     * ??? could assume that P(1:1,1:n) is conformant to P'(1:n)?
     */
    if (!conformant_entities_p(p1, p2)) 
        RET("different processors", false);
    
    for (i=1; i<=ndimdist; i++) /* considering ith dim of proc */
    {
        /* conformant distributions
         */
        distribution 
            x1 = FindDistributionOfProcessorDim
              (distribute_distribution(d1), i, &td1),
            x2 = FindDistributionOfProcessorDim
              (distribute_distribution(d2), i, &td2);
        alignment at1, at2;
        int dsize = SizeOfIthDimension(p1,i);
        
        /* if the size is 1, whatever the distribution it is ok! */
        if (dsize!=1)
        {
            if (!same_distribution_p(x1, x2)) 
                RET("different distribution", false);
            
            /* conformant alignments for that pe dim
             * !!! the HPF mapping "semantics" insure that the corresponding 
             * dimension is distributed!
             */
            at1 = FindAlignmentOfTemplateDim(align_alignment(al1), td1);
            at2 = FindAlignmentOfTemplateDim(align_alignment(al2), td2);
 
            if (!same_alignment_p(a1,t1,at1,a2,t2,at2)) 
                RET("different alignment", false);
        }
    }
 
    pips_debug(6, "similar distributions!\n");
    return true;
}

References align_alignment, align_template, conformant_entities_p(), distribute_distribution, distribute_processors, entity_name, FindAlignmentOfTemplateDim(), FindDistributionOfProcessorDim(), load_hpf_alignment(), load_hpf_distribution(), load_primary_entity(), NumberOfDimension(), pips_assert, pips_debug, RET, same_alignment_p(), same_distribution_p(), and SizeOfIthDimension().

Referenced by check_for_similarity().

Here is the call graph for this function:

Here is the caller graph for this function:

array_synonym_aligned_as()

entity array_synonym_aligned_as	(	entity	array,
		align	a
	)

entity array_synonym_aligned_as(array, a) entity array; align a;

what: finds or creates a new entity aligned as needed. input: an array (which must be dynamic) and an align output: returns an array aligned as specified by align a side effects:

• creates a new entity if necessary.
• this entity is stored as a synonym of array, and tagged as dynamic.
• the align is freed if not used. bugs or features:

the one found is returned

else no compatible array does exist, so one must be created

Parameters

array

rray

Definition at line 449 of file dynamic.c.

{
    ifdebug(8)
    {
        pips_debug(8, "array %s\n", entity_name(array));
        print_align(a);
    }
 
    MAP(ENTITY, ar,
    {
        if (same_align_p(load_hpf_alignment(ar), a))
        {
            free_align(a);
            return ar;    /* the one found is returned */
        }
    },
        entities_list(load_dynamic_hpf(array)));
 
    /*  else no compatible array does exist, so one must be created
     */
    return new_synonym_array(array, a);
}

References array, entities_list, ENTITY, entity_name, free_align(), ifdebug, load_dynamic_hpf(), load_hpf_alignment(), MAP, new_synonym_array(), pips_debug, print_align(), and same_align_p().

Referenced by hpfc_translate_call_with_distributed_args(), one_align_directive(), and one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

check_for_similarity()

static void check_for_similarity ( entity  a, list  others  )

static

no templates!

job already done

look for copies with similar mappings for latter update

a -> init[e] for storage purposes

Parameters

others

array a to be compared against its similars of entity

Definition at line 230 of file dynamic.c.

{
    bool similar_found = false;
 
    pips_debug(3, "of %s\n", entity_name(a));
 
    if (!array_distributed_p(a)) /* no templates! */
        return;
 
    if (bound_similar_mapping_p(a)) /* job already done */
        return;
 
    /* look for copies with similar mappings for latter update
     */
    MAP(ENTITY, e,
    {
        pips_debug(7, "%s against %s\n", entity_name(a), entity_name(e));
        if (a!=e && array_distribution_similar_p(e, a))
        {
            /* a -> init[e] for storage purposes 
             */
            pips_debug(8, "found similar: %s -> %s\n", 
                       entity_name(a), entity_name(e));
            store_similar_mapping(a, load_similar_mapping(e));
            similar_found = true;
            break;
        }
    },
        others);
 
    if (!similar_found) store_similar_mapping(a, a);
 
    return;
}

References array_distributed_p(), array_distribution_similar_p(), bound_similar_mapping_p(), ENTITY, entity_name, load_similar_mapping(), MAP, pips_debug, and store_similar_mapping().

Referenced by hpfc_check_for_similarities().

Here is the call graph for this function:

Here is the caller graph for this function:

close_dynamic_locals()

void close_dynamic_locals

(

void

)

can't close it directly...

Definition at line 817 of file dynamic.c.

{
    close_alive_synonym();
    close_used_dynamics();
    close_modified_dynamics();
    close_reaching_mappings();
    close_leaving_mappings();
    close_remapped();
 
    /*  can't close it directly...
     */
    CONTROLMAP_MAP(s, c, 
      {
          what_stat_debug(9, s);
 
          control_statement(c) = statement_undefined;
          gen_free_list(control_successors(c)); control_successors(c) = NIL;
          gen_free_list(control_predecessors(c)); control_predecessors(c) = NIL;
      },
                   get_remapping_graph());
 
    close_remapping_graph();
}

References control_predecessors, control_statement, control_successors, CONTROLMAP_MAP, gen_free_list(), NIL, statement_undefined, and what_stat_debug.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

close_dynamic_status()

void close_dynamic_status

(

void

)

Definition at line 117 of file dynamic.c.

{
    close_dynamic_hpf();
    close_primary_entity();
    close_renamings();
    close_maybeuseful_mappings();
    close_similar_mapping();
}

References close_dynamic_hpf(), close_maybeuseful_mappings(), close_primary_entity(), close_renamings(), and close_similar_mapping().

Here is the call graph for this function:

conformant_entities_p()

static bool conformant_entities_p ( entity  e1, entity  e2  )

static

Definition at line 329 of file dynamic.c.

{
    int ndim;
    if (e1==e2) return true;
 
    ndim = NumberOfDimension(e1);
 
    if (ndim!=NumberOfDimension(e2)) return false;
 
    for (; ndim>0; ndim--)
    {
        int l1, u1, l2, u2;
        get_entity_dimensions(e1, ndim, &l1, &u1);
        get_entity_dimensions(e2, ndim, &l2, &u2);
        if (l1!=l2 || u1!=u2) return false;
    }
 
    return true;
}

References get_entity_dimensions(), and NumberOfDimension().

Referenced by array_distribution_similar_p(), conformant_templates_p(), hpfc_translate_call_with_distributed_args(), and same_distribute_p().

Here is the call graph for this function:

Here is the caller graph for this function:

conformant_templates_p()

bool conformant_templates_p	(	entity	t1,
		entity	t2
	)

Parameters

t1	1
t2	2

Definition at line 405 of file dynamic.c.

{
    if (t1==t2) 
        return true;
    else if (!conformant_entities_p(t1, t2))
        return false;
    else
        return same_distribute_p
            (load_hpf_distribution(t1), load_hpf_distribution(t2));
}

References conformant_entities_p(), load_hpf_distribution(), and same_distribute_p().

Referenced by align_check(), and same_align_p().

Here is the call graph for this function:

Here is the caller graph for this function:

continue_propagation_p()

static bool continue_propagation_p ( statement  s )

static

up to the template!

the variable is realigned.

else it may be a call because of ALIGN () WITH T()X...

up to the processor, stop

if template t is redistributed...

Definition at line 990 of file dynamic.c.

{
    instruction i = statement_instruction(s);
 
    what_stat_debug(8, s);
    DEBUG_STAT(9, "current", s);
 
    if (!instruction_call_p(i)) 
    {
        ret("not a call", true);
    }
    else
    {
        call c = instruction_call(i);
        entity fun = call_function(c);
        
        if (rename_directive_p(fun) && array_propagation)
        {
            entity
                primary = safe_load_primary_entity(old_variable),
                array;
 
            DEBUG_STAT(8, "rename directive", s);
 
            array = expression_to_entity(EXPRESSION(CAR(call_arguments(c))));
 
            if (safe_load_primary_entity(array)==primary)
            {
                add_alive_synonym(s, new_variable);
                add_as_a_closing_statement(s);
                ret("rename to the same", false);
            }
        }
        else if (realign_directive_p(fun) && array_propagation)
        {
            entity primary = safe_load_primary_entity(old_variable);
            int nbofargs = gen_length(call_arguments(c));
 
            DEBUG_STAT(8, "realign directive", s);
 
            MAP(EXPRESSION, e,
            {
                nbofargs--;
                if (expression_reference_p(e)) 
                {
                    reference r = expression_to_reference(e);
                    entity var = reference_variable(r);
                    
                    if (nbofargs==0) /* up to the template! */
                        ret("template of realign", true);
                
                    if (safe_load_primary_entity(var)==primary)
                    {
                        /*  the variable is realigned.
                         */
                        add_alive_synonym(s, new_variable);
                        add_as_a_closing_statement(s);
                        ret("realign array",  false);
                    }
                }
                /* else it may be a call because of ALIGN () WITH T()::X...
                 */
            },
                call_arguments(c));
        }
        else if (redistribute_directive_p(fun))
        {
            entity t = safe_load_primary_entity(array_propagation ?
                align_template(load_hpf_alignment(new_variable)):old_variable);
                
            DEBUG_STAT(8, "redistribute directive", s);
 
            MAP(EXPRESSION, e,
            {
                entity v = expression_to_entity(e);
 
                if (!entity_template_p(v)) /* up to the processor, stop */
                    ret("processors of distribute", true);
 
                /*   if template t is redistributed...
                 */
                if (safe_load_primary_entity(v)==t)
                {
                    if (array_propagation)
                        add_alive_synonym(s, new_variable);
                    add_as_a_closing_statement(s);
 
                    ret("redistribute template", false);
                }
            },
                call_arguments(c));
        }
        else if (dead_fcd_directive_p(fun) && array_propagation)
        {
            entity primary = safe_load_primary_entity(old_variable);
            
            MAP(EXPRESSION, e, 
                if (primary==expression_to_entity(e)) ret("dead array", false),
                call_arguments(c)); 
        }
 
        ret("default", true);
    }
}

References add_alive_synonym(), add_as_a_closing_statement(), align_template, array, array_propagation, call_arguments, call_function, CAR, dead_fcd_directive_p(), DEBUG_STAT, entity_template_p(), EXPRESSION, expression_reference_p(), expression_to_entity(), expression_to_reference(), gen_length(), instruction_call, instruction_call_p, load_hpf_alignment(), MAP, new_variable, old_variable, realign_directive_p(), redistribute_directive_p(), reference_variable, rename_directive_p(), ret, safe_load_primary_entity(), statement_instruction, and what_stat_debug.

Referenced by propagate_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_current_remapping_graph()

void dump_current_remapping_graph

(

string

when

)

Parameters

when

hen

Definition at line 1440 of file dynamic.c.

{
    dump_remapping_graph(when, list_of_remapping_statements());
}

References dump_remapping_graph(), and list_of_remapping_statements().

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_remapping_graph()

static void dump_remapping_graph ( string  when, list  ls  )

static

Parameters

ls	of statement

Definition at line 1431 of file dynamic.c.

{
    fprintf(stderr, "[dump_remapping_graph] for %s\n", when);
    gen_map((gen_iter_func_t)dump_remapping_graph_info, ls);
    fprintf(stderr, "[dump_remapping_graph] done\n");
}

References dump_remapping_graph_info(), fprintf(), and gen_map().

Referenced by dump_current_remapping_graph(), and simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_remapping_graph_info()

static void dump_remapping_graph_info ( statement  s )

static

Definition at line 1410 of file dynamic.c.

{
    control c = load_remapping_graph(s);
 
    what_stat_debug(1, s);
 
    fprintf(stderr, "predecessors: ");
    gen_map((gen_iter_func_t)print_control_ordering, control_predecessors(c));
    fprintf(stderr, "\nsuccessors: ");
    gen_map((gen_iter_func_t)print_control_ordering, control_successors(c));
    fprintf(stderr, "\n");
 
    elst_ifdef("remapped", remapped, s);
    elst_ifdef("used", used_dynamics, s);
    elst_ifdef("modified", modified_dynamics, s);
    elst_ifdef("reaching", reaching_mappings, s);
    elst_ifdef("leaving", leaving_mappings, s);
    elst_ifdef("maybe useful", maybeuseful_mappings, s);
}

References control_predecessors, control_successors, elst_ifdef, fprintf(), gen_map(), print_control_ordering(), and what_stat_debug.

Referenced by dump_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_copy_loop_nest()

statement generate_copy_loop_nest	(	entity	src,
		entity	trg
	)

statement generate_copy_loop_nest(src, trg) entity src, trg;

what: generates a parallel loop nest that copies src in trg. how: by building the corresponding AST. input: the two entities, which should be arrays with the same shape. output: a statement containing the loop nest. side effects:

• adds a few new variables for the loop indexes. bugs or features:
• could be more general?

of entities

of expressions

of dimensions

???

builds the set of indexes needed to scan the dimensions.

builds the assign statement to put in the body. TRG(indexes) = SRC(indexes)

builds the copy loop nest

Parameters

src	rc
trg	rg

Definition at line 1568 of file dynamic.c.

{
    type t = entity_type(src);
    list /* of entities */    indexes = NIL,
         /* of expressions */ idx_expr,
         /* of dimensions */  dims;
    statement current;
    entity module;
    int ndims, i;
 
    if (src==trg) return make_empty_statement();
 
    pips_assert("valid arguments",
                array_distributed_p(src) && array_distributed_p(trg) &&
                type_variable_p(t) &&
                load_primary_entity(src)==load_primary_entity(trg)); /* ??? */
 
    dims = variable_dimensions(type_variable(t));
    ndims = gen_length(dims);
    
    /*  builds the set of indexes needed to scan the dimensions.
     */
    for(module=get_current_module_entity(), i=ndims; i>0; i--)
      indexes = CONS(ENTITY, 
                     hpfc_new_variable(module, MakeBasic(is_basic_int)),
                     indexes);
 
    idx_expr = entities_to_expressions(indexes);
 
    /*  builds the assign statement to put in the body.
     *  TRG(indexes) = SRC(indexes)
     */
    current = make_assign_statement
        (reference_to_expression(make_reference(trg, idx_expr)),
         reference_to_expression(make_reference(src, gen_copy_seq(idx_expr))));
 
    /*  builds the copy loop nest
     */
    for(; ndims>0; POP(dims), POP(indexes), ndims--)
    {
        dimension d = DIMENSION(CAR(dims));
        
        current = loop_to_statement
            (make_loop(ENTITY(CAR(indexes)),
                       make_range(copy_expression(dimension_lower(d)),
                                  copy_expression(dimension_upper(d)),
                                  int_to_expression(1)),
                       current,
                       entity_empty_label(),
                       make_execution(is_execution_parallel, UU),
                       NIL));
    }
 
    DEBUG_STAT(7, concatenate(entity_name(src), " -> ", entity_name(trg), NULL),
               current);
 
    return current;
}

References array_distributed_p(), CAR, concatenate(), CONS, copy_expression(), current, DEBUG_STAT, DIMENSION, dimension_lower, dimension_upper, entities_to_expressions(), ENTITY, entity_empty_label(), entity_name, entity_type, gen_copy_seq(), gen_length(), get_current_module_entity(), hpfc_new_variable(), int_to_expression(), is_basic_int, is_execution_parallel, load_primary_entity(), loop_to_statement, make_assign_statement(), make_empty_statement, make_execution(), make_loop(), make_range(), make_reference(), MakeBasic(), module, NIL, pips_assert, POP, reference_to_expression(), src, type_variable, type_variable_p, UU, and variable_dimensions.

Referenced by clean_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dynamic_status()

dynamic_status get_dynamic_status

(

void

)

get_similar_mapping()

Definition at line 99 of file dynamic.c.

{
    return make_dynamic_status(get_dynamic_hpf(), 
                               get_primary_entity(), 
                               get_renamings(),
                               get_maybeuseful_mappings());
    /* get_similar_mapping() */
}

References get_dynamic_hpf(), get_maybeuseful_mappings(), get_primary_entity(), get_renamings(), and make_dynamic_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:

hpfc_call_with_distributed_args_p()

bool hpfc_call_with_distributed_args_p

(

call

c

)

whether call c inplies a distributed argument

no intrinsics

else checks for distributed arguments

Definition at line 645 of file dynamic.c.

{
    entity f = call_function(c);
    int len = gen_length(call_arguments(c));
 
    /* no intrinsics */
    if (value_intrinsic_p(entity_initial(f)) ||
        hpf_directive_entity_p(f)) return false;
    
    /* else checks for distributed arguments */
    for (; len>0; len--)
    {
        entity arg = find_ith_parameter(f, len);
        if (array_distributed_p(arg)) return true;
    }
 
    return false;
}

References array_distributed_p(), call_arguments, call_function, entity_initial, f(), find_ith_parameter(), gen_length(), hpf_directive_entity_p(), and value_intrinsic_p.

Referenced by prescription_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_check_for_similarities()

void hpfc_check_for_similarities

(

list

le

)

check all dynamic arrays for some similars...

of entity

similar bases

Parameters

le

of entity

Definition at line 269 of file dynamic.c.

{
    MAP(ENTITY, array,
    {
        if (array_distributed_p(array))
        {
            list /* of entity */ 
                seens = CONS(ENTITY, array, NIL); /* similar bases */
            
            pips_assert("is a primary!", primary_entity_p(array));
            
            check_for_similarity(array, NIL);
            
            MAP(ENTITY, a,
            {
                if (!gen_in_list_p(a, seens))
                {
                    entity similar;
                    check_for_similarity(a, seens);
                    similar = load_similar_mapping(a);
                    pips_debug(1, "%s similar to %s\n",
                               entity_name(a), entity_name(similar));
                    
                    seens = gen_once(similar, seens);
                }
            },
                entities_list(load_dynamic_hpf(array)));
            
            gen_free_list(seens);
        }
    },
        le);
}

References array, array_distributed_p(), check_for_similarity(), CONS, entities_list, ENTITY, entity_name, gen_free_list(), gen_in_list_p(), gen_once(), load_dynamic_hpf(), load_similar_mapping(), MAP, NIL, pips_assert, pips_debug, and primary_entity_p.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_translate_call_with_distributed_args()

void hpfc_translate_call_with_distributed_args	(	statement	s,
		call	c
	)

??? only simple calls are handled.

imbrication may cause problems. ??? should recurse thru all the calls at a call instruction... the call. (not necessarily an instruction)

of remapping

of expression

the substitution in the call will be performed at the propagation phase of dynamic arrays, later on.

add the renaming in the list. ??? should be added only once! what about call(A,A)...

should always be the case

of statement

Do not forget to move forbidden information associated with block:

Parameters

c	the statement the call belongs to

Definition at line 687 of file dynamic.c.

{
    list /* of remapping */ lr = NIL,
         /* of expression */ args;
    int len, i;
    entity f;
 
    f = call_function(c);
    args = call_arguments(c);
    len = gen_length(args);
 
    pips_debug(1, "function %s\n", entity_name(f));
 
    for (i=1; i<=len; i++, POP(args))
    {
        entity arg = find_ith_parameter(f, i);
        pips_debug(7, "considering argument %d\n", i);
 
        if (array_distributed_p(arg))
        {
            align al;
            entity passed, copy;
            expression e = EXPRESSION(CAR(args));
 
            passed = expression_to_entity(e);
 
            pips_debug(8, "passed:%s, arg:%s\n", 
                       entity_name(passed), entity_name(arg));
            pips_assert("distributed and conformant",
                        array_distributed_p(passed) &&
                        conformant_entities_p(passed, arg));
 
            set_entity_as_dynamic(passed);
            add_a_dynamic(passed);
 
            al = copy_align(load_hpf_alignment(arg));
            copy = array_synonym_aligned_as(passed, al);
 
            pips_debug(3, "%s (arg %d) %s -> %s\n", entity_name(arg), i, 
                       entity_name(passed), entity_name(copy));
 
            /* the substitution in the call will be performed at the 
             * propagation phase of dynamic arrays, later on.
             */
            /* add the renaming in the list.
             * ??? should be added only once! what about call(A,A)...
             */
            lr = add_once_to_renaming_list(lr, passed, copy);
        }
    }
 
    if (lr) /* should always be the case */
    {
        list /* of statement */ lpre = NIL, lpos = NIL;
        entity rename = hpfc_name_to_entity(HPF_PREFIX RENAME_SUFFIX);
        
        lpre = CONS(STATEMENT, 
                    instruction_to_statement(statement_instruction(s)), 
                    NIL);
 
        MAP(RENAMING, r,
        {
            entity passed = renaming_old(r);
            entity copied = renaming_new(r);
 
            lpre = CONS(STATEMENT, call_to_statement(make_call(rename,
                        CONS(EXPRESSION, entity_to_expression(passed),
                        CONS(EXPRESSION, entity_to_expression(copied), NIL)))),
                        lpre);
 
            lpos = CONS(STATEMENT, call_to_statement(make_call(rename,
                        CONS(EXPRESSION, entity_to_expression(copied),
                        CONS(EXPRESSION, entity_to_expression(passed), NIL)))),
                        lpos);
        },
            lr);
 
        statement_instruction(s) = 
            make_instruction_block(gen_nconc(lpre, lpos));
        /* Do not forget to move forbidden information associated with
           block: */
        fix_sequence_statement_attributes(s);   
        
        DEBUG_STAT(3, "out", s);
    }
}

References add_a_dynamic(), add_once_to_renaming_list(), array_distributed_p(), array_synonym_aligned_as(), call_arguments, call_function, call_to_statement, CAR, conformant_entities_p(), CONS, copy_align(), DEBUG_STAT, entity_name, entity_to_expression(), EXPRESSION, expression_to_entity(), f(), find_ith_parameter(), fix_sequence_statement_attributes(), gen_length(), gen_nconc(), HPF_PREFIX, hpfc_name_to_entity(), instruction_to_statement(), load_hpf_alignment(), make_call(), make_instruction_block(), MAP, NIL, pips_assert, pips_debug, POP, RENAME_SUFFIX, RENAMING, renaming_new, renaming_old, set_entity_as_dynamic(), STATEMENT, and statement_instruction.

Referenced by prescription_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

init_dynamic_locals()

void init_dynamic_locals

(

void

)

DYNAMIC LOCAL DATA.

these static functions are used to store the remapping graph while it is built, or when optimizations are performed on it.

• alive_synonym: used when building the remapping graph. synonym of a primary entity that has reached a given remapping statement. Used for both arrays and templates.
• used_dynamics: from a remapping statement, the remapped arrays that are actually referenced in their new shape.
• modified_dynamics: from a remapping statement, the remapped arrays that may be modified in their new shape.
• remapping_graph: the remapping graph, based on the control domain. the control_statement is the remapping statement in the code. predecessors and successors are the possible remapping statements for the arrays remapped at that vertex.
• reaching_mappings: the mappings that may reached a vertex.
• leaving_mappings: the mappings that may leave the vertex. (simplification assumption: only one per array)
• remapped: the (primary) arrays remapped at the vertex.

Definition at line 806 of file dynamic.c.

{
    init_alive_synonym();
    init_used_dynamics();
    init_modified_dynamics();
    init_reaching_mappings();
    init_leaving_mappings();
    init_remapped();
    init_remapping_graph();
}

Referenced by handle_hpf_directives().

Here is the caller graph for this function:

init_dynamic_status()

void init_dynamic_status

(

void

)

DYNAMIC STATUS management.

Definition at line 81 of file dynamic.c.

{
    init_dynamic_hpf();
    init_primary_entity();
    init_renamings();
    init_maybeuseful_mappings();
    init_similar_mapping();
}

References init_dynamic_hpf(), init_maybeuseful_mappings(), init_primary_entity(), init_renamings(), and init_similar_mapping().

Referenced by init_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_maybeuseful_mappings()

static void initialize_maybeuseful_mappings ( statement  s )

static

must be called after useless leaving mappings removal

Definition at line 1194 of file dynamic.c.

{
    store_maybeuseful_mappings(s, copy_entities(load_leaving_mappings(s)));    
}

References copy_entities(), and store_maybeuseful_mappings().

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_reaching_propagation()

static void initialize_reaching_propagation ( statement  s )

static

for statement s

• remapped arrays
• reaching mappings (1 per array, or more)
• leaving mappings (1 per remapped array, to simplify)

of entities

Definition at line 1142 of file dynamic.c.

{
    list /* of entities */ le = NIL, lp = NIL, ll = NIL;
    entity old, new;
 
    what_stat_debug(4, s);
 
    MAP(RENAMING, r,
    {
        old = renaming_old(r);
        new = renaming_new(r);
        
        le = gen_once(old, le);
        lp = gen_once(load_primary_entity(old), lp);
        ll = gen_once(new, ll);
    },   
        load_renamings(s));
 
    store_reaching_mappings(s, make_entities(le));
    store_remapped(s, make_entities(lp));
    store_leaving_mappings(s, make_entities(ll));
}

References gen_once(), load_primary_entity(), load_renamings(), make_entities(), MAP, NIL, RENAMING, renaming_new, renaming_old, and what_stat_debug.

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

lazy_initialize_for_statement()

static void lazy_initialize_for_statement ( statement  s )

static

starting point

initialize both the remapping graph and the used dynamics for s

Definition at line 870 of file dynamic.c.

{
    if (!bound_remapping_graph_p(s))
        store_remapping_graph(s, make_control(s, NIL, NIL));
 
    if (!bound_used_dynamics_p(s))
        store_used_dynamics(s, make_entities(NIL));
 
    if (!bound_modified_dynamics_p(s))
        store_modified_dynamics(s, make_entities(NIL));
}

References make_control(), make_entities(), and NIL.

Referenced by add_as_a_closing_statement(), and propagate_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_remapping_statements()

static list list_of_remapping_statements ( )

static

of statements

of statements

Definition at line 1383 of file dynamic.c.

{
    list /* of statements */ l = NIL;
    CONTROLMAP_MAP(s, c,
    {
        pips_debug(9, "%p -> %p\n", s, c);
        l = CONS(STATEMENT, s, l);
    },
                   get_remapping_graph());
    return l;
}

References CONS, CONTROLMAP_MAP, NIL, pips_debug, and STATEMENT.

Referenced by dump_current_remapping_graph(), and simplify_remapping_graph().

Here is the caller graph for this function:

new_align_with_template()

align new_align_with_template	(	align	a,
		entity	t
	)

Definition at line 474 of file dynamic.c.

{
    align b = copy_align(a);
    align_template(b) = t;
    return b;
}

References align_template, and copy_align().

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

new_synonym()

static entity new_synonym ( entity  e )

static

builds a synonym for entity e.

The name is based on e, plus an underscore and a number added. May be used for templates and arrays. the new synonym is added as a synonym of e.

syn. number

the new entity is rather local!

Definition at line 198 of file dynamic.c.

{
    int n = gen_length(entities_list(load_dynamic_hpf(e))); /* syn. number */
    entity primary = load_primary_entity(e), new_e;
    const char* module = entity_module_name(e);
    char new_name[100]; 
    
    sprintf(new_name, "%s_%x", entity_local_name(primary), (unsigned int) n);
 
    pips_debug(5, "building entity %s\n", new_name);
 
    new_e = FindOrCreateEntityLikeModel(module, new_name, primary);
 
    if (storage_formal_p(entity_storage(new_e)))
    { /* the new entity is rather local! */
        storage s = entity_storage(new_e);
        entity sub = get_current_module_entity();
        entity_storage(new_e) = 
            make_storage(is_storage_ram,
              make_ram(sub,
                FindEntity(entity_local_name(sub),
                                      DYNAMIC_AREA_LOCAL_NAME), 0, NIL));
        free_storage(s);
    }
 
    AddEntityToDeclarations(new_e, get_current_module_entity());
 
    add_dynamic_synonym(new_e, e);
    return new_e;
}

References add_dynamic_synonym(), AddEntityToDeclarations(), DYNAMIC_AREA_LOCAL_NAME, entities_list, entity_local_name(), entity_module_name(), entity_storage, FindEntity(), FindOrCreateEntityLikeModel(), free_storage(), gen_length(), get_current_module_entity(), is_storage_ram, load_dynamic_hpf(), load_primary_entity(), make_ram(), make_storage(), module, NIL, pips_debug, and storage_formal_p.

Referenced by new_synonym_array(), and new_synonym_template().

Here is the call graph for this function:

Here is the caller graph for this function:

new_synonym_array()

static entity new_synonym_array ( entity  a, align  al  )

static

builds a new synonym for array a, the alignment of which will be al.

The new array is set as distributed.

Definition at line 306 of file dynamic.c.

{
    entity new_a = new_synonym(a);
    set_array_as_distributed(new_a);
    store_hpf_alignment(new_a, al);
    return new_a;
}

References new_synonym(), set_array_as_distributed(), and store_hpf_alignment().

Referenced by array_synonym_aligned_as().

Here is the call graph for this function:

Here is the caller graph for this function:

new_synonym_template()

static entity new_synonym_template ( entity  t, distribute  di  )

static

builds a new synonym for template t, the distribution of which will be di.

the new entity is set as a template, and/or as an array

Definition at line 319 of file dynamic.c.

{
    entity new_t = new_synonym(t);
    set_template(new_t);
    store_hpf_distribution(new_t, di);
    return new_t;
}

References new_synonym(), set_template(), and store_hpf_distribution().

Referenced by template_synonym_distributed_as().

Here is the call graph for this function:

Here is the caller graph for this function:

print_control_ordering()

static void print_control_ordering ( control  c )

static

functions used for debug.

Definition at line 1397 of file dynamic.c.

{
    statement s = control_statement(c);
    int so = statement_ordering(s);
    fprintf(stderr, "(%d:%d:%" PRIdPTR "), ", 
            ORDERING_NUMBER(so), ORDERING_STATEMENT(so),
            statement_ordering(s));
}

References control_statement, fprintf(), ORDERING_NUMBER, ORDERING_STATEMENT, and statement_ordering.

Referenced by dump_remapping_graph_info().

Here is the call graph for this function:

Here is the caller graph for this function:

propagate_maybeuseful_mappings()

static list propagate_maybeuseful_mappings ( statement  s, list  ls  )

static

of statements

Parameters

ls	of statement

Definition at line 1286 of file dynamic.c.

{
    return propagation_on_remapping_graph
      (s, ls, load_maybeuseful_mappings, load_modified_dynamics, true, false);
}

References load_maybeuseful_mappings(), and propagation_on_remapping_graph().

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

propagate_synonym()

void propagate_synonym	(	statement	s,
		entity	old,
		entity	new,
		bool	is_array
	)

Parameters

old	starting statement for the propagation
new	entity to be replaced
is_array	replacement for the entity true if array, false if template

Definition at line 1096 of file dynamic.c.

{
    statement current;
 
    what_stat_debug(3, s);
    pips_debug(3, "%s -> %s (%s)\n", entity_name(old), entity_name(new),
               is_array? "array": "template");
    DEBUG_STAT(7, "before propagation", get_current_module_statement());
 
    old_variable = safe_load_primary_entity(old), new_variable = new, 
    array_propagation = is_array;
    array_used = false;
    array_modified = false;
    initial_statement = s;
 
    lazy_initialize_for_statement(s);
 
    init_ctrl_graph_travel(s, continue_propagation_p);
 
    while (next_ctrl_graph_travel(&current))
        simple_switch_old_to_new(current);
 
    close_ctrl_graph_travel();
 
    if (array_used) add_as_a_used_variable(old);
    if (array_modified) add_as_a_modified_variable(old);
 
    old_variable = entity_undefined, 
    new_variable = entity_undefined;
 
    DEBUG_STAT(7, "after propagation", get_current_module_statement());
 
    pips_debug(4, "out\n");
}

References add_as_a_modified_variable(), add_as_a_used_variable(), array_modified, array_propagation, array_used, close_ctrl_graph_travel(), continue_propagation_p(), current, DEBUG_STAT, entity_name, entity_undefined, get_current_module_statement(), init_ctrl_graph_travel(), initial_statement, lazy_initialize_for_statement(), new_variable, next_ctrl_graph_travel(), old_variable, pips_debug, safe_load_primary_entity(), simple_switch_old_to_new(), and what_stat_debug.

Referenced by handle_prescriptive_directive(), initial_alignment(), one_align_directive(), and one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

propagate_used_arrays()

static list propagate_used_arrays ( statement  s, list  ls  )

static

of statements

Parameters

ls	of statements

Definition at line 1277 of file dynamic.c.

{
    return propagation_on_remapping_graph
      (s, ls, load_reaching_mappings, load_used_dynamics, false, true);
}

References propagation_on_remapping_graph().

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

propagation_on_remapping_graph()

static list propagation_on_remapping_graph ( statement  s, list  ls, entities(*)(statement)  built, entities(*)(statement)  condition, bool  local, bool  forward  )

static

more options, such as may or must?

of statement backward or forward

of entity

of entity

idem

if the built set was modified, must propagate at next step...

Parameters

ls	of statement
forward	local or remote condition

Definition at line 1223 of file dynamic.c.

{
    bool modified = false;
    entities built_set = built(s);
    list /* of entity */
        lrem = entities_list(load_remapped(s)),
        lbuilt = entities_list(built_set);
    control current = load_remapping_graph(s);
 
    MAP(CONTROL, c,
    {
        statement sc = control_statement(c);
        list /* of entity */ lp_rem = entities_list(load_remapped(sc));
        list /* idem      */ lp_cond = entities_list(condition(local?s:sc));
 
        MAP(ENTITY, e,
        {
            entity prim = load_primary_entity(e);
 
            if (gen_in_list_p(prim, lrem) && 
                gen_in_list_p(prim, lp_rem) &&
                !gen_in_list_p(prim, lp_cond) &&
                !gen_in_list_p(e, lbuilt))
            {
                what_stat_debug(5, s);
                pips_debug(5, "adding %s from\n", entity_local_name(e));
                what_stat_debug(5, sc);
 
                lbuilt = CONS(ENTITY, e, lbuilt);
                modified = true;
            }
        },
            entities_list(built(sc)));
    },
        forward ? control_predecessors(current):control_successors(current));
 
    /* if the built set was modified, must propagate at next step... */
    if (modified)
    {
        entities_list(built_set) = lbuilt;
        MAP(CONTROL, c, ls = gen_once(control_statement(c), ls), 
          forward?control_successors(current):control_predecessors(current));
    }
 
    return ls;
}

References CONS, CONTROL, control_predecessors, control_statement, control_successors, current, entities_list, ENTITY, entity_local_name(), gen_in_list_p(), gen_once(), load_primary_entity(), MAP, pips_debug, and what_stat_debug.

Referenced by propagate_maybeuseful_mappings(), and propagate_used_arrays().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_rwt()

static void ref_rwt ( reference  r )

static

Definition at line 931 of file dynamic.c.

{
    entity var = reference_variable(r);
    if (var==old_variable || var==new_variable)
    {
        reference_variable(r) = new_variable;
        array_used = true;
    }
}

References array_used, new_variable, old_variable, and reference_variable.

Referenced by simple_switch_old_to_new().

Here is the caller graph for this function:

regenerate_renamings()

static void regenerate_renamings ( statement  s )

static

regenerate the renaming structures after the optimizations performed on the remapping graph.

of entity(s)

ensures some remapping to enforce an update of the status, which may be necessary, for instance if KILL was used.

of renaming(s)

???

Definition at line 1338 of file dynamic.c.

{
    list /* of entity(s) */
        lr = entities_list(load_reaching_mappings(s)),
        ll = entities_list(load_leaving_mappings(s)),
        ln = NIL;
    
    what_stat_debug(4, s);
 
    MAP(ENTITY, target,
    {
        entity primary = load_primary_entity(target);
        bool some_source_found = false;
 
        MAP(ENTITY, source,
        {
            if (load_primary_entity(source)==primary && source!=target)
            {
                pips_debug(4, "%s -> %s\n", 
                           entity_name(source), entity_name(target));
                ln = CONS(RENAMING, make_renaming(source, target), ln);
                some_source_found = true;
            }
        },
            lr);
 
        /* ensures some remapping to enforce an update of the status,
         * which may be necessary, for instance if KILL was used.
         */
        if (!some_source_found)
        {
            pips_debug(7, "no source found for %s\n", entity_name(target));
            ln = CONS(RENAMING, make_renaming(target, target), ln);
        }
    },
        ll);
 
    {
        list /* of renaming(s) */ l = load_renamings(s);
        gen_map((gen_iter_func_t)gen_free, l), gen_free_list(l); /* ??? */
        update_renamings(s, ln);
    }
}

References CONS, entities_list, ENTITY, entity_name, gen_free(), gen_free_list(), gen_map(), load_primary_entity(), load_renamings(), make_renaming(), MAP, NIL, pips_debug, RENAMING, update_renamings(), and what_stat_debug.

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

reinitialize_reaching_mappings()

static void reinitialize_reaching_mappings ( statement  s )

static

of entity

new reachings

Definition at line 1199 of file dynamic.c.

{
    entities er = load_reaching_mappings(s);
    list /* of entity */ newr = NIL, /* new reachings */
                         lrem = entities_list(load_remapped(s));
 
    gen_free_list(entities_list(er));
 
    MAP(CONTROL, c,
    {
        MAP(ENTITY, e,
        {
            if (gen_in_list_p(load_primary_entity(e), lrem))
                newr = gen_once(e, newr);
        },
            entities_list(load_leaving_mappings(control_statement(c))));
    },
        control_predecessors(load_remapping_graph(s)));
 
    entities_list(er) = newr;
}

References CONTROL, control_predecessors, control_statement, entities_list, ENTITY, gen_free_list(), gen_in_list_p(), gen_once(), load_primary_entity(), MAP, and NIL.

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_from_entities()

static void remove_from_entities ( entity  primary, entities  es  )

static

of entity(s)

Definition at line 1294 of file dynamic.c.

{
    list /* of entity(s) */ le = gen_copy_seq(entities_list(es));
 
    MAP(ENTITY, array,
    {
        if (load_primary_entity(array)==primary)
            gen_remove(&entities_list(es), array);
    },
        le);
 
    gen_free_list(le);
}

References array, entities_list, ENTITY, gen_copy_seq(), gen_free_list(), gen_remove(), load_primary_entity(), and MAP.

Referenced by remove_unused_remappings().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_not_remapped_leavings()

static void remove_not_remapped_leavings ( statement  s )

static

of entities

REMAPPED and

NOT USED

=> NOT LEAVED

Definition at line 1166 of file dynamic.c.

{
    entities leaving  = load_leaving_mappings(s);
    list /* of entities */ 
        ll = entities_list(leaving),
        ln = gen_copy_seq(ll),
        lr = entities_list(load_remapped(s)),
        lu = entities_list(load_used_dynamics(s));
    entity primary;
 
    MAP(ENTITY, array,
    {
        primary = load_primary_entity(array);
        
        if (gen_in_list_p(primary, lr) && /* REMAPPED and */
            !gen_in_list_p(primary, lu))  /* NOT USED */
        {
            what_stat_debug(4, s);
            pips_debug(4, "removing %s\n", entity_name(array));
            gen_remove(&ln, array);         /* => NOT LEAVED */
        }
    },
        ll);
 
    gen_free_list(ll), entities_list(leaving) = ln;
}

References array, entities_list, ENTITY, entity_name, gen_copy_seq(), gen_free_list(), gen_in_list_p(), gen_remove(), load_primary_entity(), MAP, pips_debug, and what_stat_debug.

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_unused_remappings()

static void remove_unused_remappings ( statement  s )

static

of entity(s)

Definition at line 1310 of file dynamic.c.

{
    entities remapped = load_remapped(s),
             reaching = load_reaching_mappings(s),
             leaving = load_leaving_mappings(s);
    list /* of entity(s) */ le = gen_copy_seq(entities_list(remapped)),
                            lu = entities_list(load_used_dynamics(s));
 
    MAP(ENTITY, primary,
    {
        pips_debug(5, "considering array %s\n", entity_name(primary));
 
        if (!storage_formal_p(entity_storage(primary)) &&
            !gen_in_list_p(primary, lu))
        {
            remove_from_entities(primary, remapped);
            remove_from_entities(primary, reaching);
            remove_from_entities(primary, leaving);
        }
    },
        le);
 
    gen_free_list(le);
}

References entities_list, ENTITY, entity_name, entity_storage, gen_copy_seq(), gen_free_list(), gen_in_list_p(), MAP, pips_debug, remove_from_entities(), and storage_formal_p.

Referenced by simplify_remapping_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

rename_directive_p()

static bool rename_directive_p ( entity  f )

static

Definition at line 978 of file dynamic.c.

{
    return same_string_p(entity_local_name(f), HPF_PREFIX RENAME_SUFFIX);
}

References entity_local_name(), f(), HPF_PREFIX, RENAME_SUFFIX, and same_string_p.

Referenced by continue_propagation_p().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_dynamic_status()

void reset_dynamic_status

(

void

)

reset_similar_mapping();

Definition at line 90 of file dynamic.c.

{
    reset_dynamic_hpf();
    reset_primary_entity();
    reset_renamings();
    reset_maybeuseful_mappings();
    /* reset_similar_mapping(); */
}

References reset_dynamic_hpf(), reset_maybeuseful_mappings(), reset_primary_entity(), and reset_renamings().

Referenced by reset_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_load_primary_entity()

entity safe_load_primary_entity

(

entity

e

)

HPFC module by Fabien COELHO.

This file provides functions used by directives.c to deal with dynamic mappings (re*). It includes keeping track of variables tagged as dynamic, and managing the static synonyms introduced to deal with them in HPFC. DYNAMIC MANAGEMENT

the synonyms of a given array are stored in a entities. What I intend as a synonym is a version of the array or template which is distributed or aligned in a different way. the renamings are associated to the remapping statements here.

• dynamic_hpf: keeps track of entities declared as dynamic.
• primary_entity: primary entity of an entity, when synonyms are introduced to handle remappings.
• renamings: remappings associated to a statement.
• maybeuseful_mappings: to be kept for a statement.
• similar_mapping: copies with similar mappings...

Definition at line 61 of file dynamic.c.

{
    if (!bound_dynamic_hpf_p(e))
        pips_user_error("%s is not dynamic\n", entity_local_name(e));
   
    return load_primary_entity(e);
}

References bound_dynamic_hpf_p(), entity_local_name(), load_primary_entity(), and pips_user_error.

Referenced by alive_arrays(), continue_propagation_p(), and propagate_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

same_align_p()

static bool same_align_p ( align  a1, align  a2  )

static

of alignments

Definition at line 418 of file dynamic.c.

{
    list /* of alignments */ l1 = align_alignment(a1),
                             l2 = align_alignment(a2);
 
    if (!conformant_templates_p(align_template(a1),align_template(a2)) ||
        (gen_length(l1)!=gen_length(l2))) 
        return false;
 
    MAP(ALIGNMENT, a,
        if (!same_alignment_in_list_p(a, l2)) return false,
        l1);
 
    return true;
}

References align_alignment, align_template, ALIGNMENT, conformant_templates_p(), gen_length(), MAP, and same_alignment_in_list_p().

Referenced by array_synonym_aligned_as().

Here is the call graph for this function:

Here is the caller graph for this function:

same_alignment_in_list_p()

static bool same_alignment_in_list_p ( alignment  a, list  l  )

static

comparison of ALIGN.

Parameters

l	of alignments

Definition at line 385 of file dynamic.c.

{
    intptr_t adim = alignment_arraydim(a),
        tdim = alignment_templatedim(a);
 
    MAP(ALIGNMENT, b,
    {
        if (adim==alignment_arraydim(b) && tdim==alignment_templatedim(b))
            return expression_equal_p(alignment_rate(a), 
                                      alignment_rate(b)) &&
                   expression_equal_p(alignment_constant(a), 
                                      alignment_constant(b));
    },
        l);
 
    return false;
}

References ALIGNMENT, alignment_arraydim, alignment_constant, alignment_rate, alignment_templatedim, expression_equal_p(), intptr_t, and MAP.

Referenced by same_align_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_alignment_p()

static bool same_alignment_p ( entity  e1, entity  t1, alignment  a1, entity  e2, entity  t2, alignment  a2  )

static

compares the alignments if any

Definition at line 535 of file dynamic.c.

{
    int b1, l1, b2, l2;
    bool b;
 
    if (alignment_undefined_p(a1) || alignment_undefined_p(a2))
    {
        b=alignment_undefined_p(a1) && alignment_undefined_p(a2);
        RETAL("some undefined", b);
    }
 
    pips_debug(7, "considering %s[dim=%"PRIdPTR"] and %s[dim=%"PRIdPTR"]\n",
               entity_name(e1), alignment_arraydim(a1),
               entity_name(e2), alignment_arraydim(a2));
 
    /* compares the alignments if any 
     */
    if (alignment_arraydim(a1)!=alignment_arraydim(a2)) 
        RETAL("diff. array dim", false);
 
    if (!expression_equal_p(alignment_rate(a1), alignment_rate(a2)))
        RETAL("different rate", false);
 
    if (SizeOfIthDimension(t1, alignment_templatedim(a1))!=
        SizeOfIthDimension(t2, alignment_templatedim(a2)))
        RETAL("different template size", false);
 
    b1 = HpfcExpressionToInt(alignment_constant(a1));
    b2 = HpfcExpressionToInt(alignment_constant(a2));
    l1 = HpfcExpressionToInt
        (dimension_lower(FindIthDimension(t1,alignment_templatedim(a1))));
    l2 = HpfcExpressionToInt
        (dimension_lower(FindIthDimension(t2,alignment_templatedim(a2))));
 
    b=(b1-l1)==(b2-l2);
    RETAL("shift", b);
}

References alignment_arraydim, alignment_constant, alignment_rate, alignment_templatedim, alignment_undefined_p, b1, b2, dimension_lower, entity_name, expression_equal_p(), FindIthDimension(), HpfcExpressionToInt(), pips_debug, RETAL, and SizeOfIthDimension().

Referenced by array_distribution_similar_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_distribute_p()

static bool same_distribute_p ( distribute  d1, distribute  d2  )

static

comparison of DISTRIBUTE.

of distributions

Definition at line 353 of file dynamic.c.

{
    list /* of distributions */ l1 = distribute_distribution(d1),
                                l2 = distribute_distribution(d2);
 
    if (!conformant_entities_p(distribute_processors(d1),
                               distribute_processors(d2))) return false;
    
    pips_assert("valid distribution", gen_length(l1)==gen_length(l2));
 
    for(; !ENDP(l1); POP(l1), POP(l2))
    {
        distribution i1 = DISTRIBUTION(CAR(l1)),
                     i2 = DISTRIBUTION(CAR(l2));
        style s1 = distribution_style(i1),
              s2 = distribution_style(i2);
        tag t1 = style_tag(s1);
 
        if (t1!= (tag) style_tag(s2)) return false;
        if (t1!=is_style_none &&
            !expression_equal_p(distribution_parameter(i1),
                                distribution_parameter(i2)))
            return false;
    }
 
    return true;
}

References CAR, conformant_entities_p(), distribute_distribution, distribute_processors, DISTRIBUTION, distribution_parameter, distribution_style, ENDP, expression_equal_p(), gen_length(), is_style_none, pips_assert, POP, s1, and style_tag.

Referenced by conformant_templates_p(), and template_synonym_distributed_as().

Here is the call graph for this function:

Here is the caller graph for this function:

same_distribution_p()

static bool same_distribution_p ( distribution  d1, distribution  d2  )

static

array_distribution_similar_p

returns whether a1 and a2 are similar, i.e. even if distributed differently, the resulting mapping is similar.

e.g. align a1(i,j) with T(i,j), distribute T(*,block) and align a2(i,j) with T(j,i), distribute T(block,*)

impact: the same area can be used for holding both array versions but the version number must be accurate.

Definition at line 523 of file dynamic.c.

{
    return 
        style_tag(distribution_style(d1))==style_tag(distribution_style(d2))
        && expression_equal_p(distribution_parameter(d1),
                              distribution_parameter(d2));
}

References distribution_parameter, distribution_style, expression_equal_p(), and style_tag.

Referenced by array_distribution_similar_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_primary_entity_p()

bool same_primary_entity_p	(	entity	e1,
		entity	e2
	)

Parameters

e1	1
e2	2

Definition at line 70 of file dynamic.c.

{
    if (bound_primary_entity_p(e1) && bound_primary_entity_p(e2))
        return load_primary_entity(e1)==load_primary_entity(e2);
    else
        return false;
}

References bound_primary_entity_p(), and load_primary_entity().

Referenced by simple_switch_old_to_new().

Here is the call graph for this function:

Here is the caller graph for this function:

set_dynamic_status()

void set_dynamic_status

(

dynamic_status

d

)

set_similar_mapping(...)

Definition at line 108 of file dynamic.c.

{
    set_dynamic_hpf(dynamic_status_dynamics(d));
    set_primary_entity(dynamic_status_primary(d));
    set_renamings(dynamic_status_renamings(d));
    set_maybeuseful_mappings(dynamic_status_tokeep(d));
    /* set_similar_mapping(...) */
}

References dynamic_status_dynamics, dynamic_status_primary, dynamic_status_renamings, dynamic_status_tokeep, set_dynamic_hpf(), set_maybeuseful_mappings(), set_primary_entity(), and set_renamings().

Referenced by load_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_entity_as_dynamic()

void set_entity_as_dynamic

(

entity

e

)

a new dynamic entity is stored.

HPF allows arrays and templates as dynamic. ??? could be asserted, but not here. should be checked afterward.

else the entity was already declared as dynamic...

Definition at line 130 of file dynamic.c.

{
    if (!bound_dynamic_hpf_p(e))
    {
        store_dynamic_hpf(e, make_entities(CONS(ENTITY, e, NIL)));
        store_primary_entity(e, e);
 
        store_similar_mapping(e, e);
    }
    /* else the entity was already declared as dynamic... */
}

References bound_dynamic_hpf_p(), CONS, ENTITY, make_entities(), NIL, store_dynamic_hpf(), store_primary_entity(), and store_similar_mapping().

Referenced by hpfc_translate_call_with_distributed_args(), and new_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

set_similar_mappings_for_updates()

void set_similar_mappings_for_updates

(

void

)

??? for final update after compilation! hummm....

??? should not deal with the same array twice...

may be in another module

Definition at line 162 of file dynamic.c.

{
    /* ??? for final update after compilation! hummm....
     */
 
    MAP(ENTITY, array,
    {
        pips_debug(7, "considering array %s\n", entity_name(array));
 
        /* ??? should not deal with the same array twice... 
         */
        if (dynamic_entity_p(array) && 
            bound_similar_mapping_p(array) && 
            bound_new_node_p(array)) /* may be in another module */
        {
            entity n = load_new_node(array);
            entity s = load_similar_mapping(array);
            entity ns = load_new_node(s);
 
            pips_debug(7, "array %s\n", entity_name(array));
            
            if (!bound_new_node_p(n)) {
                store_new_node_variable(ns, n);
                store_new_node_variable(ns, array);
            }
        }
    },
        list_of_distributed_arrays());
}

References array, bound_new_node_p(), bound_similar_mapping_p(), dynamic_entity_p, ENTITY, entity_name, list_of_distributed_arrays(), load_new_node(), load_similar_mapping(), MAP, pips_debug, and store_new_node_variable().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_switch_old_to_new()

static void simple_switch_old_to_new ( statement  s )

static

looks for direct references in s and switch them

STATEMENT

UNSTRUCTURED ?

REFERENCE

whether the array may be written... by scanning the proper effects of s. (caution, was just switched to the new_variable!)

Definition at line 941 of file dynamic.c.

{
    DEBUG_STAT(9, "considering", s);
 
    /* looks for direct references in s and switch them
     */
    gen_multi_recurse
        (statement_instruction(s),
         statement_domain,    gen_false, gen_null, /* STATEMENT */
         unstructured_domain, gen_false, gen_null, /* UNSTRUCTURED ? */
         reference_domain,    gen_true,  ref_rwt,  /* REFERENCE */
         NULL);
 
    /* whether the array may be written... by scanning the proper effects of s.
     * (caution, was just switched to the new_variable!)
     */
    pips_debug(8, "statement %p, array %s, rw proper %d\n", 
               s, entity_name(new_variable), bound_proper_rw_effects_p(s));
 
    if (!array_modified && bound_proper_rw_effects_p(s))
    {
        FOREACH(EFFECT, e, load_proper_rw_effects_list(s))
          {
            if(store_effect_p(e)) {
              entity v = reference_variable(effect_any_reference(e));
              if (same_primary_entity_p(v,new_variable) && effect_write_p(e))
                {
                  pips_debug(9, "%s W in %p\n", entity_name(new_variable), s);
                  array_modified = true;
                  return;
                }
            }
          }
    }
}

References array_modified, bound_proper_rw_effects_p(), DEBUG_STAT, EFFECT, effect_any_reference, effect_write_p, entity_name, FOREACH, gen_false(), gen_multi_recurse(), gen_null(), gen_true(), load_proper_rw_effects_list(), new_variable, pips_debug, ref_rwt(), reference_domain, reference_variable, same_primary_entity_p(), statement_domain, statement_instruction, store_effect_p(), and unstructured_domain.

Referenced by propagate_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_remapping_graph()

void simplify_remapping_graph

(

void

)

void simplify_remapping_graph()

what: simplifies the remapping graph. how: propagate unused reaching mappings to the next remappings, and remove unnecessary remappings. input: none. output: none. side effects: all is there!

• the remapping graph remappings are modified.
• some static structures are used.
• current module statement needed. bugs or features:
• special treatment of the current module statement to model the initial mapping at the entry of the module. The initial mapping may be modified by the algorithm if it is remapped before being used.
• ??? the convergence and correctness are to be proved.
• expected complexity: n vertices (small!), q nexts, m arrays, r remaps. assumes fast sets instead of lists, with O(1) tests/add/del... closure: O(n^2*vertex_operation) (if it is a simple propagation...) map: O(n*vertex_operation) C = n^2 q m r

of statements

Definition at line 1467 of file dynamic.c.

{
    list /* of statements */ ls = list_of_remapping_statements();
    statement root = get_current_module_statement();
    what_stat_debug(4, root);
 
    ifdebug(8) dump_remapping_graph("0", ls);
 
    gen_map((gen_iter_func_t)initialize_reaching_propagation, ls);
    gen_map((gen_iter_func_t)remove_not_remapped_leavings, ls);
    gen_map((gen_iter_func_t)initialize_maybeuseful_mappings, ls);
    gen_map((gen_iter_func_t)reinitialize_reaching_mappings, ls);
 
    ifdebug(4) dump_remapping_graph("1", ls);
 
    pips_debug(4, "used array propagation\n");
    gen_closure((gen_closure_func_t) propagate_used_arrays, ls);
 
    pips_debug(4, "may be useful mapping propagation\n");
    gen_closure((gen_closure_func_t) propagate_maybeuseful_mappings, ls);
 
    ifdebug(4) dump_remapping_graph("2", ls);
 
    if (bound_remapped_p(root)) remove_unused_remappings(root);
 
    gen_map((gen_iter_func_t)regenerate_renamings, ls);
 
    gen_free_list(ls);
}

References dump_remapping_graph(), gen_closure(), gen_free_list(), gen_map(), get_current_module_statement(), ifdebug, initialize_maybeuseful_mappings(), initialize_reaching_propagation(), list_of_remapping_statements(), pips_debug, propagate_maybeuseful_mappings(), propagate_used_arrays(), regenerate_renamings(), reinitialize_reaching_mappings(), remove_not_remapped_leavings(), remove_unused_remappings(), and what_stat_debug.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

template_synonym_distributed_as()

entity template_synonym_distributed_as	(	entity	temp,
		distribute	d
	)

what: finds or creates a new entity distributed as needed.

input: an template (which must be dynamic) and a distribute output: returns a template distributed as specified by d side effects:

• creates a new entity if necessary.
• this entity is stored as a synonym of array, and tagged as dynamic.
• the distribute is freed if not used.

the one found is returned

else no compatible template does exist, so one must be created

Parameters

temp

emp

Definition at line 491 of file dynamic.c.

{
    MAP(ENTITY, t,
    {
        if (same_distribute_p(load_hpf_distribution(t), d))
        {
            free_distribute(d);
            return t;    /* the one found is returned */
        }
    },
        entities_list(load_dynamic_hpf(temp)));
 
    /*  else no compatible template does exist, so one must be created
     */
    return new_synonym_template(temp, d);
}

References entities_list, ENTITY, free_distribute(), load_dynamic_hpf(), load_hpf_distribution(), MAP, new_synonym_template(), and same_distribute_p().

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

array_modified

bool array_modified

static

true if the array was actually used

Definition at line 864 of file dynamic.c.

Referenced by propagate_synonym(), and simple_switch_old_to_new().

array_propagation

bool array_propagation

static

replacement

Definition at line 862 of file dynamic.c.

Referenced by continue_propagation_p(), and propagate_synonym().

array_used

bool array_used

static

true if an array is propagated, false if template

Definition at line 863 of file dynamic.c.

Referenced by propagate_synonym(), and ref_rwt().

dynamic_entity_p

bool(* dynamic_entity_p) (entity)

(

entity

)

= bound_dynamic_hpf_p

as expected, true if entity e is dynamic.

it is just a function name nicer than bound_...

Definition at line 145 of file dynamic.c.

Referenced by add_declaration_to_host_and_link(), add_dynamic_synonym(), create_init_common_param_for_arrays(), create_parameters_h(), one_align_directive(), one_distribute_directive(), and set_similar_mappings_for_updates().

initial_statement

statement initial_statement = statement_undefined

static

true if the array may be modified...

Definition at line 866 of file dynamic.c.

Referenced by add_as_a_closing_statement(), add_as_a_modified_variable(), add_as_a_used_variable(), and propagate_synonym().

new_variable

entity new_variable = entity_undefined

static

entity to be replaced, the primary?

Definition at line 860 of file dynamic.c.

Referenced by add_parameter_variable_to_module(), add_private_variable_to_module(), build_sc_with_several_uniform_ref(), clone_variable_with_new_name(), continue_propagation_p(), create_parameter_for_new_module(), create_parameter_variable_for_new_module(), create_private_integer_variable_for_new_module(), create_private_variable_for_new_module(), declare_common_variables_in_module(), generic_clone_variable_with_unique_name(), propagate_synonym(), ref_rwt(), sc_rename_variables(), simple_switch_old_to_new(), and vect_rename_variables().

old_variable

entity old_variable = entity_undefined

static

void propagate_synonym(s, old, new) statement s; entity old, new;

what: propagates a new array/template synonym (old->new) from statement s. how: travels thru the control graph till the next remapping. input: the starting statement, plus the two entities. output: none. side effects:

• uses the crtl_graph travelling.
• set some static variables for the continuation decisions and switch. bugs or features:
• not very efficient. Could have done something to deal with several synonyms at the same time...
• what is done on an "incorrect" code is not clear.

Definition at line 859 of file dynamic.c.

Referenced by clone_variable_with_unique_name(), continue_propagation_p(), generic_clone_variable_with_unique_name(), propagate_synonym(), and ref_rwt().