io-compile.c File Reference

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

Include dependency graph for io-compile.c:

Go to the source code of this file.

Functions
static bool	current_entity_is_used_later_p (statement stat, entity current_entity)
	HPFC module by Fabien COELHO. More...
static bool	current_entity_is_updated_before_p (statement stat, entity current_entity)
	IN Regions(effects) are used to verify if the entity current_entity is initialized before it's used in the io statement. More...
static Psysteme	statement_context (statement stat, tag move)
void	hpfc_algorithm_row_echelon (Psysteme syst, list scanners, Psysteme *pcond, Psysteme *penum)
	io-compile.c More...
list	make_list_of_dummy_variables (entity(*creation)(), int number)
	of entity More...
static Psysteme	generate_shared_io_system (entity array, statement stat, tag move, tag act)
static Psysteme	generate_distributed_io_system (entity array, statement stat, tag move, tag act)
void	remove_variables_if_possible (Psysteme *psyst, list *plvars)
static Psysteme	clean_shared_io_system (Psysteme syst, entity array, tag move)
void	remove_variables_from_system (Psysteme *ps, list *plv)
void	clean_the_system (Psysteme *ps, list *plrm, list *pltry)
static Psysteme	clean_distributed_io_system (Psysteme syst, entity array, tag move)
	collect or update More...
static void	put_variables_in_ordered_lists (Psysteme *psyst, entity array, list *plparam, list *plproc, list *plscan, list *plrebuild)
	Variables of Psysteme syst are ordered and put in different lists. More...
list	simplify_deducable_variables (Psysteme syst, list vars, list *pleftvars)
	list simplify_deducable_variables(syst, vars, pleftvars) Psysteme syst; list vars, *pleftvars; More...
static list	hpfc_order_specific_variables (list le, entity(*creation)())
	output 7 entities created by creation if in list le More...
list	hpfc_order_variables (list le, bool number_first)
	list hpfc_order_variables(list) More...
void	hpfc_algorithm_tiling (Psysteme syst, list processors, list scanners, Psysteme *pcondition, Psysteme *pproc_echelon, Psysteme *ptile_echelon)
void	hpfc_simplify_condition (Psysteme *psc, statement stat, tag move)
	void hpfc_simplify_condition(psc, stat, move) More...
static Psysteme	generate_io_system (entity array, statement stat, tag move, tag act)
	generates the Psystem for IOs inside the statement stat, that use entity ent which should be a variable. More...
static void	generate_io_collect_or_update (entity array, statement stat, tag move, tag act, statement *psh, statement *psn)
static void	add_declaration_to_host_and_link (entity array)
	add a local declaration for entity array on the host. More...
void	io_efficient_compile (statement stat, statement *hp, statement *np)
	compile an io statement More...

Function Documentation

add_declaration_to_host_and_link()

static void add_declaration_to_host_and_link ( entity  array )

static

add a local declaration for entity array on the host.

if entity array is dynamic, then declaration based on the primary.

already exists, just add the link

create the host entity

second link if needed

local, not passed as an argument

Definition at line 876 of file io-compile.c.

{
    entity primary, host_array;
    storage s;
    
    if (dynamic_entity_p(array))
    {
        primary = load_primary_entity(array);
        if (bound_new_host_p(primary)) /* already exists, just add the link */
        {
            store_new_host_variable(load_new_host(primary), array);
            return;             
        }
    }
    else 
        primary = array;
    
    /* create the host entity
     */
    host_array = AddEntityToModule(primary, host_module);
    store_new_host_variable(host_array, primary);
    
    if (primary!=array) /* second link if needed */
        store_new_host_variable(host_array, array);
 
    /* local, not passed as an argument
     */
    s = entity_storage(host_array);
    if (storage_formal_p(s))
        formal_offset(storage_formal(s)) = INT_MAX;
}

References AddEntityToModule(), array, bound_new_host_p(), dynamic_entity_p, entity_storage, formal_offset, host_module, load_new_host(), load_primary_entity(), storage_formal, storage_formal_p, and store_new_host_variable().

Referenced by io_efficient_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_distributed_io_system()

static Psysteme clean_distributed_io_system ( Psysteme  syst, entity  array, tag  move  )

static

collect or update

??? what about the variables? some are usefull, some are constants, and others should be discarded. This selection and projection may be done here.

to be removed: PHIi... THETAi... some GAMMAi... some others coming from the *conditions

loop generation on: PSIi... some GAMMAi... some DELTAi... complementary ALPHAi... (LALPHAi?)

THETA_i's PHI_i's PSI_i's ALPHA_i's LALPHA_i's

Keep parameters !

should try to remove only variables that can be eliminated using the preconditions. Otherwise: ph1=old, 1<=old<=2, projecting old loses the right dimension...

try_remove = CONS(ENTITY, e, try_remove);

others

Parameters

array	system to be cleaned
move	io on array

Definition at line 373 of file io-compile.c.

{
    /* ??? what about the variables?
     * some are usefull, some are constants, and others should
     * be discarded. This selection and projection may be done here.
     */
    /* to be removed:
     * PHIi...
     * THETAi...
     * some GAMMAi...
     * some others coming from the *conditions
     *
     * loop generation on:
     * PSIi...
     * some GAMMAi...
     * some DELTAi...
     * complementary ALPHAi... (LALPHAi?)
     */
    entity
        template = array_to_template(array),
        processor = template_to_processors(template);
    int
        array_dim = NumberOfDimension(array),
        template_dim = NumberOfDimension(template),
        processor_dim = NumberOfDimension(processor);
    list
        keep = NIL, try_keep = NIL, remove = NIL,
        try_remove = base_to_list(sc_base(syst));
 
    pips_debug(5, "array %s, movement %s\n", entity_local_name(array), 
               (movement_collect_p(move))?"collect":"update");
 
    pips_assert("distributed array", array_distributed_p(array));
    
    /* THETA_i's
     * PHI_i's
     * PSI_i's
     * ALPHA_i's
     * LALPHA_i's 
     */
    add_to_list_of_vars(remove, get_ith_template_dummy, template_dim);
    add_to_list_of_vars(remove, get_ith_region_dummy, array_dim);
    add_to_list_of_vars(keep, get_ith_processor_dummy, processor_dim);
    add_to_list_of_vars(keep, get_ith_array_dummy, array_dim);
    add_to_list_of_vars(try_keep, get_ith_local_dummy, array_dim);
 
    /*   Keep parameters !
     */
    MAP(ENTITY, e,
    {
        const char* s = entity_module_name(e);
        
        if (strcmp(s, HPFC_PACKAGE) && strcmp(s, REGIONS_MODULE_NAME))
            keep = CONS(ENTITY, e, keep);
        /* should try to remove only variables that can be eliminated
         * using the preconditions. Otherwise: ph1=old, 1<=old<=2,
         * projecting old loses the right dimension...
         */
        /* try_remove = CONS(ENTITY, e, try_remove); */
    },
        try_remove);
 
    /*   others
     */
    gen_remove(&try_remove, (entity) TCST);
    MAP(ENTITY, e, gen_remove(&try_remove, e), keep);
    MAP(ENTITY, e, gen_remove(&try_remove, e), try_keep);
    MAP(ENTITY, e, gen_remove(&try_remove, e), remove);
 
    DEBUG_ELST(7, "keep", keep);
    DEBUG_ELST(7, "try_keep", try_keep);
    DEBUG_ELST(7, "try_remove", try_remove);
    DEBUG_ELST(7, "remove", remove);
 
    clean_the_system(&syst, &remove, &try_remove);
    
    DEBUG_SYST(6, entity_name(array), syst);
    
    gen_free_list(keep);
    gen_free_list(try_keep);
    gen_free_list(try_remove);
 
    return(syst);
}

References add_to_list_of_vars, array, array_distributed_p(), array_to_template, base_to_list(), clean_the_system(), CONS, DEBUG_ELST, DEBUG_SYST, ENTITY, entity_local_name(), entity_module_name(), entity_name, gen_free_list(), gen_remove(), get_ith_array_dummy(), get_ith_local_dummy(), get_ith_processor_dummy(), get_ith_region_dummy(), get_ith_template_dummy(), HPFC_PACKAGE, keep, MAP, movement_collect_p, NIL, NumberOfDimension(), pips_assert, pips_debug, REGIONS_MODULE_NAME, TCST, and template_to_processors.

Referenced by generate_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_shared_io_system()

static Psysteme clean_shared_io_system ( Psysteme  syst, entity  array, tag  move  )

static

ALPHA_i's PHI_i's

keep parameters !

others

remove variables that have to be removed

Try to remove other unusefull variables

the noisy system is cleaned some variables are not used, they are removed here.

Definition at line 285 of file io-compile.c.

{
    int array_dim = NumberOfDimension(array);
    list keep = NIL, try_keep = NIL, remove = NIL,
         try_remove = base_to_list(sc_base(syst));
 
    pips_debug(5, "array %s, movement %s\n", entity_local_name(array), 
               (movement_collect_p(move))?"collect":"update");
 
    /* ALPHA_i's
     * PHI_i's
     */
    add_to_list_of_vars(keep, get_ith_array_dummy, array_dim);
    add_to_list_of_vars(remove, get_ith_region_dummy, array_dim);
    
    /*   keep parameters !
     */
    MAP(ENTITY, e,
     {
         const char* s = entity_module_name(e);
 
         if (strcmp(s, HPFC_PACKAGE) && strcmp(s, REGIONS_MODULE_NAME))
             keep = CONS(ENTITY, e, keep);
     },
         try_remove);
 
    /*   others
     */
    gen_remove(&try_remove, (entity) TCST);
    MAP(ENTITY, e, gen_remove(&try_remove, e), keep);
    MAP(ENTITY, e, gen_remove(&try_remove, e), try_keep);
    MAP(ENTITY, e, gen_remove(&try_remove, e), remove);
    
    /*    remove variables that have to be removed
     */
    MAP(ENTITY, e, 
        sc_projection_along_variable_ofl_ctrl(&syst, (Variable) e, NO_OFL_CTRL),
        remove);
    
    /* Try to remove other unusefull variables
     */
    remove_variables_if_possible(&syst, &try_remove);
 
    /* the noisy system is cleaned
     * some variables are not used, they are removed here.
     */
    build_sc_nredund_2pass(&syst);
    base_rm(sc_base(syst));
    sc_base(syst) = BASE_NULLE;
    sc_creer_base(syst);
 
    DEBUG_SYST(6, entity_name(array), syst);
    
    return(syst);
}

References add_to_list_of_vars, array, BASE_NULLE, base_rm, base_to_list(), build_sc_nredund_2pass(), CONS, DEBUG_SYST, ENTITY, entity_local_name(), entity_module_name(), entity_name, gen_remove(), get_ith_array_dummy(), get_ith_region_dummy(), HPFC_PACKAGE, keep, MAP, movement_collect_p, NIL, NO_OFL_CTRL, NumberOfDimension(), pips_debug, REGIONS_MODULE_NAME, remove_variables_if_possible(), sc_creer_base(), and TCST.

Referenced by generate_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_the_system()

void clean_the_system	(	Psysteme *	ps,
		list *	plrm,
		list *	pltry
	)

Parameters

ps	s
plrm	of entities
pltry	ltry

Definition at line 360 of file io-compile.c.

{
    remove_variables_from_system(ps, plrm);
    remove_variables_if_possible(ps, pltry);
 
    build_sc_nredund_2pass(ps);
    base_rm(sc_base(*ps)), sc_creer_base(*ps);
}

References base_rm, build_sc_nredund_2pass(), remove_variables_from_system(), remove_variables_if_possible(), and sc_creer_base().

Referenced by clean_distributed_io_system(), and hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

current_entity_is_updated_before_p()

static bool current_entity_is_updated_before_p ( statement  stat, entity  current_entity  )

static

IN Regions(effects) are used to verify if the entity current_entity is initialized before it's used in the io statement.

& OUT Regions are not used

get IN Regions(Effects) list for the io statement

list_in = load_statement_in_regions(stat);

for all IN Regions (Effects) for the statement stat, test if reference in current_effect is egal to current_entity

Definition at line 84 of file io-compile.c.

{
    list list_in; 
 
    if (get_bool_property("HPFC_IGNORE_IN_OUT_REGIONS"))        /* & OUT Regions are not used*/
        return true;
 
/* get IN Regions(Effects) list for the io statement */
/*    list_in = load_statement_in_regions(stat);*/
 
    list_in = load_in_effects_list(stat);
 
    ifdebug(2)
    {
        pips_debug(3, "IN regions: \n");
        print_regions(list_in);
    }
 
/* for all IN Regions (Effects) for the statement stat, 
 test if reference in current_effect is egal to current_entity */
 
    MAP(EFFECT, current_effect,
        {
            if (effect_variable(current_effect)==current_entity)
                return true;
        },
        list_in);
 
    return false;
}

References current_entity, EFFECT, effect_variable, get_bool_property(), ifdebug, load_in_effects_list(), MAP, pips_debug, and print_regions().

Referenced by io_efficient_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

current_entity_is_used_later_p()

static bool current_entity_is_used_later_p ( statement  stat, entity  current_entity  )

static

HPFC module by Fabien COELHO.

OUT Regions(effects) are used to verify if the entity current_entity is read in another statement later (note that we don't need to know which statement is reading current_entity)

N & OUT Regions are not used

get OUT Regions(Effects) list for the io statement

list_out = load_statement_out_regions(stat);

for all OUT Regions (Effects) for the statement stat, test if reference in current_effect is egal to current_entity

Definition at line 47 of file io-compile.c.

{
    list list_out; 
 
    if (get_bool_property("HPFC_IGNORE_IN_OUT_REGIONS"))
        /*IN & OUT Regions are not used*/
        return true;
 
 
/* get OUT Regions(Effects) list for the io statement */
/*    list_out = load_statement_out_regions(stat);*/
 
    list_out = load_out_effects_list(stat);
 
    ifdebug(2)
    {
        pips_debug(3, "OUT regions: \n");
        print_regions(list_out);
    }
 
/* for all OUT Regions (Effects) for the statement stat, 
 test if reference in current_effect is egal to current_entity */
 
    MAP(EFFECT, current_effect,
        {
            if (effect_variable(current_effect)==current_entity)
                return true;
        },
        list_out);    
 
    return false;
}

References current_entity, EFFECT, effect_variable, get_bool_property(), ifdebug, load_out_effects_list(), MAP, pips_debug, and print_regions().

Referenced by io_efficient_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_distributed_io_system()

static Psysteme generate_distributed_io_system ( entity  array, statement  stat, tag  move, tag  act  )

static

??? bug: the preconditions may be in the regions. To update, I should have the postconditions instead, that is the statement transformer should be applied to the system.

???

??? massive memory leak polyhedron intersections

the noisy system is cleaned some variables are not used, they are removed here.

Definition at line 197 of file io-compile.c.

{
    Psysteme result = SC_UNDEFINED,
        /* ??? bug: the preconditions may be in the regions.  To update, I
         * should have the postconditions instead, that is the statement
         * transformer should be applied to the system.
         */
        region = effect_system(entity_to_region(stat, array, act)),
        dist_v = generate_system_for_distributed_variable(array),
        sother = hpfc_compute_unicity_constraints(array), /* ??? */
        stamme = hpfc_unstutter_dummies(array),
        contxt = statement_context(stat, move);
    
    /* ??? massive memory leak 
       polyhedron intersections
*/
    result = sc_append(sc_rn(NULL), region);
    result = sc_append(result, dist_v);
    result = sc_append(result, sother);
    result = sc_append(result, stamme);
    result = sc_append(result, contxt);
    
    DEBUG_SYST(8, concatenate("whole: ", entity_name(array), NULL), result);
    
    /* the noisy system is cleaned
     * some variables are not used, they are removed here.
     */
    build_sc_nredund_2pass(&result);
    base_rm(sc_base(result));
    sc_base(result) = NULL;
    sc_creer_base(result);
    
    DEBUG_SYST(9, "region", region);
    DEBUG_SYST(9, "array syst", dist_v);
    DEBUG_SYST(9, "hpf unicity", sother);
    DEBUG_SYST(9, "unstammer", stamme);
    DEBUG_SYST(9, "context", contxt);
    
    DEBUG_SYST(6, concatenate("result: ", entity_name(array), NULL), result);
    
    return(result);
}

References array, base_rm, build_sc_nredund_2pass(), concatenate(), DEBUG_SYST, effect_system, entity_name, entity_to_region(), generate_system_for_distributed_variable(), hpfc_compute_unicity_constraints(), hpfc_unstutter_dummies(), region, sc_append(), sc_creer_base(), sc_rn(), and statement_context().

Referenced by generate_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_io_collect_or_update()

static void generate_io_collect_or_update ( entity  array, statement  stat, tag  move, tag  act, statement *  psh, statement *  psn  )

static

SCANNING: Variables must be classified as:

• parameters
• processors
• scanner
• deducable

Now we have a set of equations and inequations, and we are going to organise a scanning of the data and the communications that are needed

the sorting is done again at the code generation, but this phase will ensure more determinism in the debug messages

sc_vect_sort(condition, compare_Pvecteur);

array not distributed

the sorting is done again at the code generation, but this phase will ensure more determinism in the debug messages

sc_vect_sort(condition, compare_Pvecteur);

Definition at line 769 of file io-compile.c.

{
    Psysteme syst = generate_io_system(array, stat, move, act);
    set_information_for_code_optimizations(syst);
 
    pips_assert("variable and syst",
                entity_variable_p(array) && syst!=SC_UNDEFINED);
 
    if (array_distributed_p(array))
    {
        /* SCANNING: Variables must be classified as:
         *   - parameters 
         *   - processors
         *   - scanner
         *   - deducable
         */
        Psysteme proc_echelon, tile_echelon, condition;
        list parameters = NIL, processors = NIL, scanners = NIL, rebuild = NIL;
 
        /* Now we have a set of equations and inequations, and we are going
         * to organise a scanning of the data and the communications that 
         * are needed
         */
        put_variables_in_ordered_lists
            (&syst, array, &parameters, &processors, &scanners, &rebuild); 
 
        hpfc_algorithm_tiling(syst, processors, scanners, 
                              &condition, &proc_echelon, &tile_echelon);
        hpfc_simplify_condition(&condition, stat, move);
 
        /*  the sorting is done again at the code generation,
         *  but this phase will ensure more determinism in the debug messages
         */
        /* sc_vect_sort(condition, compare_Pvecteur); */
        sc_sort(condition, sc_base(condition), compare_Pvecteur);
        sc_vect_sort(proc_echelon, compare_Pvecteur);
        sc_vect_sort(tile_echelon, compare_Pvecteur);
 
        if (!sc_empty_p(proc_echelon) && !sc_empty_p(tile_echelon))
        {
            generate_io_statements_for_distributed_arrays
                (array, move, 
                 condition, proc_echelon, tile_echelon,
                 parameters, processors, scanners, rebuild,
                 psh, psn);
        }
        else
        {
            hpfc_warning("empty io for %s\n", entity_name(array));
            *psh = make_continue_statement(entity_undefined);
            *psn = make_continue_statement(entity_undefined);
        }
    }
    else  /* array not distributed */
    {
        Psysteme row_echelon = SC_UNDEFINED, condition = SC_UNDEFINED;
        list tmp = NIL, parameters = NIL, scanners = NIL, rebuild = NIL;
 
        pips_assert("update", movement_update_p(move));
 
        put_variables_in_ordered_lists
            (&syst, array, &parameters, &tmp, &scanners, &rebuild);
 
        pips_assert("empty list", ENDP(tmp));
 
        hpfc_algorithm_row_echelon(syst, scanners, &condition, &row_echelon);
        hpfc_simplify_condition(&condition, stat, move);
 
        /*  the sorting is done again at the code generation,
         *  but this phase will ensure more determinism in the debug messages
         */
        /* sc_vect_sort(condition, compare_Pvecteur); */
        sc_sort(condition, sc_base(condition), compare_Pvecteur);
        sc_vect_sort(row_echelon, compare_Pvecteur);
 
        if (!sc_empty_p(row_echelon))
        {
            generate_io_statements_for_shared_arrays
                (array, move,
                 condition, row_echelon,
                 parameters, scanners, rebuild,
                 psh, psn);
        }
        else
        {
            hpfc_warning("empty io for %s\n", entity_name(array));
            *psh = make_continue_statement(entity_undefined);
            *psn = make_continue_statement(entity_undefined);
        }
    }
 
    reset_information_for_code_optimizations();
 
    DEBUG_STAT(8, "Host", *psh);
    DEBUG_STAT(8, "Node", *psn);
}

References array, array_distributed_p(), compare_Pvecteur(), DEBUG_STAT, ENDP, entity_name, entity_undefined, entity_variable_p, generate_io_statements_for_distributed_arrays(), generate_io_statements_for_shared_arrays(), generate_io_system(), hpfc_algorithm_row_echelon(), hpfc_algorithm_tiling(), hpfc_simplify_condition(), hpfc_warning, make_continue_statement(), movement_update_p, NIL, pips_assert, put_variables_in_ordered_lists(), reset_information_for_code_optimizations(), sc_empty_p(), sc_sort(), sc_vect_sort(), and set_information_for_code_optimizations().

Referenced by io_efficient_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_io_system()

static Psysteme generate_io_system ( entity  array, statement  stat, tag  move, tag  act  )

static

generates the Psystem for IOs inside the statement stat, that use entity ent which should be a variable.

Definition at line 740 of file io-compile.c.

{
    Psysteme result = SC_UNDEFINED;
 
    pips_assert("variable", entity_variable_p(array));
 
    if (array_distributed_p(array))
    {
        result = generate_distributed_io_system(array, stat, move, act);
        result = clean_distributed_io_system(result, array, move);
    }
    else
    {
        result = generate_shared_io_system(array, stat, move, act);
        result = clean_shared_io_system(result, array, move);
    }
 
    sc_vect_sort(result, compare_Pvecteur);
 
    DEBUG_SYST(2, concatenate("array ", entity_name(array), NULL), result);
 
    return result;
}

References array, array_distributed_p(), clean_distributed_io_system(), clean_shared_io_system(), compare_Pvecteur(), concatenate(), DEBUG_SYST, entity_name, entity_variable_p, generate_distributed_io_system(), generate_shared_io_system(), pips_assert, and sc_vect_sort().

Referenced by generate_io_collect_or_update().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_shared_io_system()

static Psysteme generate_shared_io_system ( entity  array, statement  stat, tag  move, tag  act  )

static

??? bug post with region

the noisy system is cleaned some variables are not used, they are removed here.

Definition at line 156 of file io-compile.c.

{
    Psysteme
        result = SC_UNDEFINED, /* ??? bug post with region */
        region = effect_system(entity_to_region(stat, array, act)), 
        a_decl = entity_to_declaration_constraints(array, 0),
        stamme = hpfc_unstutter_dummies(array),
        contxt = statement_context(stat, move);
 
    pips_assert("distributed array", !array_distributed_p(array));
 
    result = sc_append(sc_rn(NULL), region);
    result = sc_append(result, a_decl);
    result = sc_append(result, stamme);
    result = sc_append(result, contxt);
    
    DEBUG_SYST(8, concatenate("whole: ", entity_name(array), NULL), result);
    
    /* the noisy system is cleaned
     * some variables are not used, they are removed here.
     */
    sc_nredund(&result);
    base_rm(sc_base(result));
    sc_base(result) = NULL;
    sc_creer_base(result);
    
    DEBUG_SYST(7, "region", region);
    DEBUG_SYST(7, "array declaration", a_decl);
    DEBUG_SYST(7, "unstammer", stamme);
    DEBUG_SYST(7, "context", contxt);
    
    DEBUG_SYST(6, concatenate("result: ", entity_name(array), NULL), result);
    
    return result;
}

References array, array_distributed_p(), base_rm, concatenate(), DEBUG_SYST, effect_system, entity_name, entity_to_declaration_constraints(), entity_to_region(), hpfc_unstutter_dummies(), pips_assert, region, sc_append(), sc_creer_base(), sc_rn(), and statement_context().

Referenced by generate_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_algorithm_row_echelon()

void hpfc_algorithm_row_echelon	(	Psysteme	syst,
		list	scanners,
		Psysteme *	pcond,
		Psysteme *	penum
	)

io-compile.c

this should improve conditions?

Parameters

syst	yst
scanners	canners
pcond	cond
penum	enum

Definition at line 127 of file io-compile.c.

{
    Pbase base = entity_list_to_base(scanners);
    algorithm_row_echelon_generic(syst, base, pcond, penum,
        get_bool_property("HPFC_REDUNDANT_SYSTEMS_FOR_REMAPS"));
    /* this should improve conditions? */
    sc_find_equalities(pcond);
    base_rm(base);
}

References algorithm_row_echelon_generic(), base, base_rm, entity_list_to_base(), get_bool_property(), and sc_find_equalities().

Referenced by generate_io_collect_or_update(), hpf_remapping(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_algorithm_tiling()

void hpfc_algorithm_tiling	(	Psysteme	syst,
		list	processors,
		list	scanners,
		Psysteme *	pcondition,
		Psysteme *	pproc_echelon,
		Psysteme *	ptile_echelon
	)

Parameters

syst	yst
processors	rocessors
scanners	canners
pcondition	condition
pproc_echelon	proc_echelon
ptile_echelon	tile_echelon

Definition at line 689 of file io-compile.c.

{
    Pbase
        outer = entity_list_to_base(processors),
        inner = entity_list_to_base(scanners);
 
    DEBUG_SYST(8, "initial system", syst);
 
    algorithm_tiling(syst, outer, inner, 
                     pcondition, pproc_echelon, ptile_echelon);
 
    DEBUG_SYST(3, "condition", *pcondition);
    DEBUG_BASE(3, "proc vars", outer);
    DEBUG_SYST(3, "processors", *pproc_echelon);
    DEBUG_BASE(3, "tile vars", inner);
    DEBUG_SYST(3, "tiles", *ptile_echelon);
 
    base_rm(outer);
    base_rm(inner);
}

References algorithm_tiling(), base_rm, DEBUG_BASE, DEBUG_SYST, and entity_list_to_base().

Referenced by generate_io_collect_or_update().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_order_specific_variables()

static list hpfc_order_specific_variables ( list  le, entity(*)()  creation  )

static

output 7 entities created by creation if in list le

of entity

Definition at line 605 of file io-compile.c.

{
    list result = NIL;
    int i;
 
    for(i=7; i>=1; i--)
    {
        entity dummy = creation(i);
 
        if (gen_in_list_p(dummy, le))
            result = CONS(ENTITY, dummy, result);
    }
 
    return(result);
}

References CONS, ENTITY, gen_in_list_p(), and NIL.

Referenced by hpfc_order_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_order_variables()

list hpfc_order_variables	(	list	le,
		bool	number_first
	)

list hpfc_order_variables(list)

the input list of entities is ordered so that: PSI_i's, GAMMA_i's, DELTA_i's, IOTA_i's, ALPHA_i's, LALPHA_i's...

reverse!

Parameters

le	e
number_first	umber_first

Definition at line 629 of file io-compile.c.

{
    list result = NIL;
 
    result =
        gen_nconc(result,
                  hpfc_order_specific_variables(le, get_ith_processor_dummy));
    
    if (number_first)
    {
        int i;
        list l = NIL, lr = NIL;
 
        for (i=7; i>0; i--)
            l = CONS(ENTITY, get_ith_array_dummy(i),
                CONS(ENTITY, get_ith_shift_dummy(i),
                CONS(ENTITY, get_ith_block_dummy(i),
                CONS(ENTITY, get_ith_cycle_dummy(i),
                       l))));
 
        MAP(ENTITY, e,
        {
            if (gen_in_list_p(e, le)) lr = CONS(ENTITY, e, lr); /* reverse! */
        },
            l);
 
        gen_free_list(l);
        result = gen_nconc(result, lr);
    }
    else
    {
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_cycle_dummy));
        
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_block_dummy));
        
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_shift_dummy));
        
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_array_dummy));
    }
 
    result = 
        gen_nconc(result,
                  hpfc_order_specific_variables(le, get_ith_local_dummy));
 
    pips_assert("same length", gen_length(result)==gen_length(le));
    
    return(result);
}

References CONS, ENTITY, gen_free_list(), gen_in_list_p(), gen_length(), gen_nconc(), get_ith_array_dummy(), get_ith_block_dummy(), get_ith_cycle_dummy(), get_ith_local_dummy(), get_ith_processor_dummy(), get_ith_shift_dummy(), hpfc_order_specific_variables(), MAP, NIL, and pips_assert.

Referenced by put_variables_in_ordered_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_simplify_condition()

void hpfc_simplify_condition	(	Psysteme *	psc,
		statement	stat,
		tag	move
	)

void hpfc_simplify_condition(psc, stat, move)

remove conditions that are not usefull from *psc, i.e. that are redundent with pre/post conditions depending on when the movement is done

Parameters

psc	sc
stat	tat
move	ove

Definition at line 724 of file io-compile.c.

{
    Psysteme
        pstrue = statement_context(stat, move),
        cleared = extract_nredund_subsystem(*psc, pstrue);
 
    *psc = (sc_rm(*psc), cleared);
}

References extract_nredund_subsystem(), sc_rm(), and statement_context().

Referenced by generate_io_collect_or_update().

Here is the call graph for this function:

Here is the caller graph for this function:

io_efficient_compile()

void io_efficient_compile	(	statement	stat,
		statement *	hp,
		statement *	np
	)

compile an io statement

returned Node code

of effect

not implemented

Parameters

stat	tat
hp	statement to compile
np	returned Host code

Definition at line 911 of file io-compile.c.

{
  list
    /* of effect */ entities = load_rw_effects_list(stat),
    lh_collect = NIL, lh_io = NIL, lh_update = NIL,
    ln_collect = NIL, ln_io = NIL, ln_update = NIL;
  statement sh, sn;
 
  debug_on("HPFC_IO_DEBUG_LEVEL");
  pips_debug(1, "compiling!\n");
  pips_debug(2, "statement %" _intFMT " (%p), %zd arrays\n",
             statement_number(stat), stat, gen_length(entities));
 
  // quicker for continue and so...
  if (empty_code_p(stat))
  {
    pips_debug(3, "empty statement\n");
    *hp = copy_statement(stat);
    *np = copy_statement(stat);
    debug_off();
    return;
  }
 
  // for each effect e on that statement
  FOREACH(effect, e, entities)
  {
    entity array = reference_variable(effect_any_reference(e));
    pips_debug(3, "variable %s\n", entity_name(array));
 
    if (io_effect_entity_p(array)) // skip LUNS
      continue;
 
    action act = effect_action(e);
    approximation apr = effect_approximation(e);
 
    pips_assert("avoid replicated array I/O", /* not implemented */
                !(array_distributed_p(array) && replicated_p(array)));
 
    if ((!array_distributed_p(array)) && action_read_p(act))
    {
      pips_debug(7, "skipping array %s movements - none needed\n",
                 entity_name(array));
      continue;
    }
 
    // add array declaration on host if necessary
    if (array_distributed_p(array) && !bound_new_host_p(array))
      add_declaration_to_host_and_link(array);
 
    // collect data if necessary
    if (array_distributed_p(array) &&
        current_entity_is_updated_before_p(stat,array) &&
        (action_read_p(act) ||
         (action_write_p(act) &&
          approximation_may_p(apr) &&
          !get_bool_property("HPFC_IGNORE_MAY_IN_IO"))))
    {
      generate_io_collect_or_update(array, stat, is_movement_collect,
                                    action_tag(act), &sh, &sn);
      lh_collect = CONS(STATEMENT, sh, lh_collect);
      ln_collect = CONS(STATEMENT, sn, ln_collect);
    }
 
    // update data if necessary
    // action = write and data may be used later (out regions)
    if (action_write_p(act) && current_entity_is_used_later_p(stat,array))
    {
      generate_io_collect_or_update(array, stat, is_movement_update,
                                    action_tag(act), &sh, &sn);
      lh_update = CONS(STATEMENT, sh, lh_update);
      ln_update = CONS(STATEMENT, sn, ln_update);
    }
  }
 
  lh_io =  CONS(STATEMENT, copy_statement(stat), NIL);
 
  if (get_bool_property("HPFC_SYNCHRONIZE_IO"))
  {
    // could do it only for write statements
    entity synchro = hpfc_name_to_entity(SYNCHRO);
 
    lh_io = CONS(STATEMENT, hpfc_make_call_statement(synchro, NIL), lh_io);
    ln_io = CONS(STATEMENT, hpfc_make_call_statement(synchro, NIL), ln_io);
  }
 
  *hp = make_block_statement(gen_nconc(lh_collect,
                             gen_nconc(lh_io,
                                       lh_update)));
  *np = make_block_statement(gen_nconc(ln_collect,
                             gen_nconc(ln_io,
                                       ln_update)));
 
  DEBUG_STAT(9, "Host", *hp);
  DEBUG_STAT(9, "Node", *np);
 
  debug_off();
}

References _intFMT, action_read_p, action_tag, action_write_p, add_declaration_to_host_and_link(), approximation_may_p, array, array_distributed_p(), bound_new_host_p(), CONS, copy_statement(), current_entity_is_updated_before_p(), current_entity_is_used_later_p(), debug_off, debug_on, DEBUG_STAT, effect_action, effect_any_reference, effect_approximation, empty_code_p(), entity_name, FOREACH, gen_length(), gen_nconc(), generate_io_collect_or_update(), get_bool_property(), hpfc_make_call_statement(), hpfc_name_to_entity(), io_effect_entity_p(), is_movement_collect, is_movement_update, load_rw_effects_list(), make_block_statement(), NIL, pips_assert, pips_debug, reference_variable, replicated_p(), STATEMENT, statement_number, and SYNCHRO.

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

make_list_of_dummy_variables()

list make_list_of_dummy_variables	(	entity(*)()	creation,
		int	number
	)

of entity

Definition at line 143 of file io-compile.c.

{
    list result = NIL;
 
    for(;number>0;number--)
        result = CONS(ENTITY, creation(number), result);
 
    return result;
}

References CONS, ENTITY, and NIL.

put_variables_in_ordered_lists()

static void put_variables_in_ordered_lists ( Psysteme *  psyst, entity  array, list *  plparam, list *  plproc, list *  plscan, list *  plrebuild  )

static

Variables of Psysteme syst are ordered and put in different lists.

Especially, deducable variables are listed, the equalities that allow to rebuild them are also listed, and they are removed from the original system by exact integer projection.

Other variables are (should be) the parameters, the processors, and the variables to be used to scan polyhedron.

just in case

parameters: those variables that are not dummies...

processors

scanners and deducables

return results

lscan is implicitely ordered

Definition at line 470 of file io-compile.c.

{
    int processor_dim = (array_distributed_p(array) ?
            NumberOfDimension(array_to_processors(array)) : 0 ),
        dim = -1;
    list
        all = base_to_list(sc_base(*psyst)),
        lparam = NIL, lproc = NIL, lscan = NIL, lrebuild = NIL;
 
    gen_remove(&all, (entity) TCST); /* just in case */
 
    pips_debug(5, "considering %zd variables\n", gen_length(all));
 
    /* parameters: those variables that are not dummies...
     */
    MAP(ENTITY, v,
        if (!entity_hpfc_dummy_p(v)) lparam = CONS(ENTITY, v, lparam),
        all);
 
    MAP(ENTITY, e, gen_remove(&all, e), lparam);
    
    /* processors
     */
    for(dim=processor_dim; dim>=1; dim--)
    {
        entity
            dummy = get_ith_processor_dummy(dim);
 
        lproc = CONS(ENTITY, dummy, lproc);
        gen_remove(&all, dummy);
    }
 
    /* scanners and deducables
     */
    lrebuild = 
        simplify_deducable_variables(*psyst,
                                     gen_nreverse(hpfc_order_variables(all,
                                                                       true)),
                                     &lscan);
 
    /* return results
     */
    *plparam    = lparam, 
    *plproc     = lproc, 
    *plscan     = lscan, /* lscan is implicitely ordered */
    *plrebuild  = lrebuild;
 
    gen_free_list(all);
 
    DEBUG_ELST(4, "params", lparam);
    DEBUG_ELST(4, "procs", lproc);
    DEBUG_ELST(4, "scanners", lscan);
 
    ifdebug(4)
    {
        Pcontrainte pc = contrainte_make(VECTEUR_NUL);
 
        fprintf(stderr, "deducables:\n   ");
        MAP(EXPRESSION, ex,
        {
            pc->vecteur = normalized_linear(expression_normalized(ex));
            
            fprintf(stderr, "%s rebuilt with ", entity_local_name
                    (reference_variable(expression_reference(ex))));
            egalite_fprint(stderr, pc, (string(*)(Variable))entity_local_name);
        },
            lrebuild);
    }
 
    build_sc_nredund_2pass(psyst);
    sc_base(*psyst) = (base_rm(sc_base(*psyst)), BASE_NULLE);
    sc_creer_base(*psyst);
 
    DEBUG_SYST(4, entity_name(array), *psyst);
}

References array, array_distributed_p(), array_to_processors, BASE_NULLE, base_rm, base_to_list(), build_sc_nredund_2pass(), CONS, contrainte_make(), DEBUG_ELST, DEBUG_SYST, egalite_fprint(), ENTITY, entity_hpfc_dummy_p(), entity_local_name(), entity_name, EXPRESSION, expression_normalized, expression_reference(), fprintf(), gen_free_list(), gen_length(), gen_nreverse(), gen_remove(), get_ith_processor_dummy(), hpfc_order_variables(), ifdebug, MAP, NIL, normalized_linear, NumberOfDimension(), pips_debug, reference_variable, sc_creer_base(), simplify_deducable_variables(), TCST, Scontrainte::vecteur, and VECTEUR_NUL.

Referenced by generate_io_collect_or_update().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_variables_from_system()

void remove_variables_from_system	(	Psysteme *	ps,
		list *	plv
	)

Parameters

ps	s
plv	of entity (Variable)

Definition at line 345 of file io-compile.c.

{
    MAP(ENTITY, e,
    {
        pips_debug(8, "removing variable %s\n", entity_local_name(e));
        sc_projection_along_variable_ofl_ctrl(ps, (Variable) e, NO_OFL_CTRL);
    },
        *plv);
 
    gen_free_list(*plv), *plv=NIL;
}

References ENTITY, entity_local_name(), gen_free_list(), MAP, NIL, NO_OFL_CTRL, and pips_debug.

Referenced by clean_the_system().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_variables_if_possible()

void remove_variables_if_possible	(	Psysteme *	psyst,
		list *	plvars
	)

Parameters

psyst	syst
plvars	lvars

Definition at line 245 of file io-compile.c.

{
    Psysteme syst = *psyst;
    list kept = NIL;
 
    MAP(ENTITY, e, 
    {
        Variable var = (Variable) e;
        Value coeff = VALUE_MONE;
        
        (void) contrainte_var_min_coeff(sc_egalites(syst), var, &coeff, false);
        
        if (value_one_p(coeff))
        {
            Pvecteur v = vect_new(var, VALUE_ONE);
            bool exact = true;
            
            pips_debug(7, "removing variable %s\n", 
                       entity_local_name((entity) var));
            
            sc_projection_along_variables_with_test_ofl_ctrl
                (&syst, v, &exact, NO_OFL_CTRL);
 
            pips_assert("exact projection", exact);
            vect_rm(v);
        }
        else
            kept = CONS(ENTITY, (entity) var, kept);
    }, 
        *plvars);
    
    base_rm(sc_base(syst)), sc_base(syst) = BASE_NULLE, sc_creer_base(syst);
    
    *psyst = syst;
    gen_free_list(*plvars), *plvars=kept;
}

References BASE_NULLE, base_rm, CONS, contrainte_var_min_coeff(), ENTITY, entity_local_name(), gen_free_list(), MAP, NIL, NO_OFL_CTRL, pips_assert, pips_debug, sc_creer_base(), VALUE_MONE, VALUE_ONE, value_one_p, vect_new(), and vect_rm().

Referenced by clean_shared_io_system(), and clean_the_system().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_deducable_variables()

list simplify_deducable_variables	(	Psysteme	syst,
		list	vars,
		list *	pleftvars
	)

list simplify_deducable_variables(syst, vars, pleftvars) Psysteme syst; list vars, *pleftvars;

variables from entity list vars that can be rebuilt by the Psysteme syst are removed from it and stored as an expression list which is returned. The variables that are not removed are returned as another entity list, *pleftvars. of expression

Parameters

syst	yst
vars	ars
pleftvars	leftvars

Definition at line 562 of file io-compile.c.

{
    list result = NIL;
    *pleftvars = NIL;
 
    MAP(ENTITY, dummy,
    {
        Pcontrainte eq = CONTRAINTE_UNDEFINED;
        Value coeff = VALUE_ZERO;
        
         if (eq = eq_v_min_coeff(sc_egalites(syst), (Variable) dummy, &coeff),
             value_one_p(coeff))
         {
             result = 
                 CONS(EXPRESSION,
                      make_expression(make_syntax(is_syntax_reference,
                                                  make_reference(dummy, NIL)),
                                      make_normalized(is_normalized_linear,
                                                      vect_dup(eq->vecteur))), 
                      result);
 
             syst = sc_variable_substitution_with_eq_ofl_ctrl(syst, eq, 
                                                              (Variable) dummy,
                                                              FWD_OFL_CTRL);
         }
         else
         {
             *pleftvars = CONS(ENTITY, dummy, *pleftvars);
         }
     },
         vars);
 
    base_rm(sc_base(syst)), sc_base(syst) = BASE_NULLE, sc_creer_base(syst);
 
    return(result);
}

References BASE_NULLE, base_rm, CONS, CONTRAINTE_UNDEFINED, ENTITY, eq, EXPRESSION, FWD_OFL_CTRL, is_normalized_linear, is_syntax_reference, make_expression(), make_normalized(), make_reference(), make_syntax(), MAP, NIL, sc_creer_base(), value_one_p, VALUE_ZERO, vect_dup(), and Scontrainte::vecteur.

Referenced by extract_lattice(), hpf_remapping(), and put_variables_in_ordered_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_context()

static Psysteme statement_context ( statement  stat, tag  move  )

static

Definition at line 116 of file io-compile.c.

{
    return predicate_system(transformer_relation
                            ((movement_collect_p(move)) ? 
                             load_statement_precondition(stat) :
                             load_statement_postcondition(stat))); 
}

References load_statement_postcondition(), load_statement_precondition(), movement_collect_p, predicate_system, and transformer_relation.

Referenced by generate_distributed_io_system(), generate_shared_io_system(), and hpfc_simplify_condition().

Here is the call graph for this function:

Here is the caller graph for this function: