isolate_statement.c File Reference

transfer statement to isolate memory More...

#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "misc.h"
#include "properties.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "preprocessor.h"
#include "conversion.h"
#include "control.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "semantics.h"
#include "callgraph.h"
#include "accel-util.h"

Include dependency graph for isolate_statement.c:

Go to the source code of this file.

Data Structures
struct	dma_pair
	isolate_statement More...
struct	param_t
struct	isolate_param

Functions
static size_t	get_dma_dimension (region reg_from)
static const char *	get_dma_name (enum region_to_dma_switch m, size_t d)
	converts a region_to_dma_switch to corresponding dma name according to properties More...
static bool	declarations_to_dimensions (entity e, list *dimensions, list *offsets)
void	region_to_dimensions (effect reg, transformer tr, list *dimensions, list *offsets, expression *condition)
	isolate_statement.c More...
static expression	region_to_address (region reg)
static expression	get_sizeofexpression_for_region (region reg)
	generate an expression of the form sizeof(typeof(variable[indices])) More...
list	variable_to_dimensions (region reg_from)
call	dimensions_to_dma (effect reg_from, entity to, list ld, list lo, enum region_to_dma_switch m)
	converts dimensions to a dma call from a memory from to another memory to More...
static region	extended_regions_must_convex_hull (region r0, region r1)
	perform the convex hull between r0 and r1, and merge them if they have a common prefix e.g. More...
static statement	effects_to_dma (statement stat, enum region_to_dma_switch s, hash_table e2e, expression *condition, bool fine_grain_analysis, const char *prefix, const char *suffix)
	Compute a call to a DMA function from the effects of a statement. More...
static bool	do_check_isolate_statement_preconditions_on_call (call c, param_t *p)
static bool	do_isolate_statement_preconditions_satisified_p (statement s)
void	do_isolate_statement (statement s, const char *prefix, const char *suffix)
	perform statement isolation on statement s that is make sure that all access to variables in s are made either on private variables or on new entities declared on a new memory space. More...
static void	isolate_patch_reference (reference r, isolate_param *p)
	replace reference r on entity p->old by a reference on entity p->new with offsets p->offsets More...
static void	isolate_patch_statement (statement s, isolate_param *p)
	run isolate_patch_entities on all declared entities from s More...
void	isolate_patch_entities (void *where, entity old, entity new, list offsets)
	replace all references on entity old by references on entity new and adds offset offsets to its indices More...
static void	bounds_of_expression (expression e, transformer tr, bool is_upper)
	replaces expression e by its upper or lower bound under preconditions tr is_upper is used to choose among lower and upperbound More...
static void	upperbound_of_expression (expression e, transformer tr)
	replaces expression e by its upperbound under preconditions tr More...
static void	lowerbound_of_expression (expression e, transformer tr)
	replaces expression e by its lowerbound under preconditions tr More...
bool	region_to_minimal_dimensions (region r, transformer tr, list *dims, list *offsets, bool exact, expression *condition)
	generate a list of dimensions dims and of offsets from a region r for example if r = a[phi0,phi1] 0<=phi0<=2 and 1<=phi1<=4 we get dims = ( (0,3), (0,4) ) and offsets = ( 0 , 1 ) if exact is set to false, we are allowed to give an upper bound to the dimensions More...
region	find_region_on_entity (entity e, list regions)
range	dimension_to_range (dimension d)
bool	isolate_statement (const char *module_name)

Variables
static const int	dma1D = 1
	Some constant intended to have a more readable code. More...

Detailed Description

transfer statement to isolate memory

Author

Serge Guelton serge.nosp@m..gue.nosp@m.lton@.nosp@m.enst.nosp@m.-bret.nosp@m.agne.nosp@m..fr

Date

2010-05-01

Definition in file isolate_statement.c.

Function Documentation

bounds_of_expression()

static void bounds_of_expression ( expression  e, transformer  tr, bool  is_upper  )

static

replaces expression e by its upper or lower bound under preconditions tr is_upper is used to choose among lower and upperbound

Definition at line 1160 of file isolate_statement.c.

{
    intptr_t lbound, ubound;
    if(precondition_minmax_of_expression(e,tr,&lbound,&ubound) &&
       // FC: minmax returns max/min int, which does not make much sense
       // and result in later possibly undetected integer overflows...
       // so explicitely disallow these special values.
       ( (is_upper && ubound < VALUE_MAX) || (!is_upper && lbound > VALUE_MIN)))
    {
        fprintf(stderr, "bound=%"_intFMT"\n", is_upper? ubound: lbound);
        free_syntax(expression_syntax(e));
        free_normalized(expression_normalized(e));
        expression new = int_to_expression(is_upper ? ubound : lbound);
        expression_syntax(e)=expression_syntax(new);
        expression_normalized(e)=expression_normalized(new);
        expression_syntax(new)=syntax_undefined;
        expression_normalized(new)=normalized_undefined;
        free_expression(new);
    }
}

References _intFMT, expression_normalized, expression_syntax, fprintf(), free_expression(), free_normalized(), free_syntax(), int_to_expression(), intptr_t, normalized_undefined, precondition_minmax_of_expression(), syntax_undefined, VALUE_MAX, and VALUE_MIN.

Referenced by lowerbound_of_expression(), and upperbound_of_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

declarations_to_dimensions()

static bool declarations_to_dimensions ( entity  e, list *  dimensions, list *  offsets  )

static

Definition at line 175 of file isolate_statement.c.

                                                                                   {
  if(!entity_array_p(e)) {
    return false;
  }
 
  // Populate "dimensions" and "offsets" by looking to the declaration
  list ldim = variable_dimensions(type_variable(ultimate_type(entity_type(e))));
  FOREACH(dimension, d, ldim) {
    // FIXME Unsure who cares about the free....
    dimension d_dup = copy_dimension(d);
    expression dl = dimension_lower(d);
 
    // Check if we have an offset (impossible in C!)
    intptr_t offset;
    bool dl_is_int_p=expression_integer_value(dl,&offset);
    pips_assert("lower bound is int",dl_is_int_p);
    if(offset!=0) {
      pips_internal_error("We shouldn't have an offset in the array declaration"
          ", are you using Fortran?");
    }
 
    *dimensions = CONS(DIMENSION, d_dup, *dimensions );
    *offsets = CONS(EXPRESSION, dl, *offsets);
  }
  return true;
 
}

References CONS, copy_dimension(), DIMENSION, dimension_lower, entity_array_p(), entity_type, EXPRESSION, expression_integer_value(), FOREACH, intptr_t, offset, pips_assert, pips_internal_error, type_variable, ultimate_type(), and variable_dimensions.

Referenced by region_to_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

dimension_to_range()

range dimension_to_range

(

dimension

d

)

Returns

a range suitable for iteration over all the elements of dimension d

Definition at line 1336 of file isolate_statement.c.

{
    return make_range(
            copy_expression(dimension_lower(d)),
            copy_expression(dimension_upper(d)),
            int_to_expression(1));
}

References copy_expression(), dimension_lower, dimension_upper, int_to_expression(), and make_range().

Referenced by do_group_constants_terapix().

Here is the call graph for this function:

Here is the caller graph for this function:

dimensions_to_dma()

call dimensions_to_dma	(	effect	reg_from,
		entity	to,
		list	ld,
		list	lo,
		enum region_to_dma_switch	m
	)

converts dimensions to a dma call from a memory from to another memory to

Parameters

from	expression giving the adress of the input memory
to	expression giving the adress of the output memory
ld	list of dimensions to analyze
m	kind of call to generate

Returns

Scalar detection:

Need the address for the allocator to modify the pointer itself:

Generate a "void **" type:

dest = "(void **) &to"

Except for the deallocation or if we have a scalar and then we have already created a pointer to it, the original array is referenced through pointer dereferencing:

sizeof(element)*number elements of the array:

Generate communication functions:

Build the sizes of the array block to transfer:

f expressions

Build the sizes of the array with element to transfer:

of expressions

Build the offsets of the array block to transfer:

of expressions

Use a special transfert function for scalars instead of reusing the 1D function. It may useful for example if it is implemented as a FIFO at the hardware level:

Generate host and accel adresses:

Output parameters in an order compatible with some C99 implementation of the runtime: size and block size first, so that some arguments can be defined with them:

Insert offset:

Insert the block size to transfert:

Insert the array sizes:

Insert the element size expression:

Parameters

reg_from	eg_from
to	o
ld	f dimensions
lo	f offsets

Definition at line 379 of file isolate_statement.c.

{
    entity from = reference_variable(region_any_reference(reg_from));
    expression dest;
    list args = NIL;
    const char* function_name = get_dma_name(m,get_dma_dimension(reg_from));
 
    entity mcpy = module_name_to_entity(function_name);
    if (entity_undefined_p(mcpy)) {
        mcpy=make_empty_subroutine(function_name,copy_language(module_language(get_current_module_entity())));
        pips_user_warning("Cannot find \"%s\" method. Are you sure you have set\n"
                "KERNEL_LOAD_STORE_..._FUNCTION "
                "to a defined entity and added the correct .c file?\n",function_name);
    }
    else if (!fortran_module_p(get_current_module_entity())) {
        AddEntityToModuleCompilationUnit(mcpy,get_current_module_entity());
    } else
        AddEntityToModule(mcpy,get_current_module_entity());
 
    /* Scalar detection: */
    bool scalar_entity = entity_scalar_p(from);
 
    if (dma_allocate_p(m)) {
        /* Need the address for the allocator to modify the pointer itself: */
        dest = MakeUnaryCall(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),entity_to_expression(to));
        /* Generate a "void **" type: */
        type voidpp = make_type_variable(
                make_variable(
                    make_basic_pointer(
                        make_type_variable(
                            make_variable(
                                make_basic_pointer(
                                    make_type_void(NIL)
                                    ),
                                NIL,NIL
                                )
                            )
                        ),
                    NIL,NIL
                    )
                );
        /* dest = "(void **) &to" */
        dest = make_expression(
                make_syntax_cast(
                    make_cast(voidpp,dest)
                    ),
                normalized_undefined);
    }
    else if (!dma_deallocate_p(m) && !scalar_entity)
        /* Except for the deallocation or if we have a scalar and then we have
           already created a pointer to it, the original array is referenced
           through pointer dereferencing: */
        dest = MakeUnaryCall(entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
                entity_to_expression(to));
    else
        dest=entity_to_expression(to);
 
 
    switch(m) {
        case dma_deallocate:
            args = make_expression_list(dest);
            break;
        case dma_allocate:
            {
                expression sizeof_exp = get_sizeofexpression_for_region(reg_from);
 
                /* sizeof(element)*number elements of the array: */
                expression transfer_size = SizeOfDimensions(ld);
                transfer_size=MakeBinaryCall(
                        entity_intrinsic(MULTIPLY_OPERATOR_NAME),
                        sizeof_exp,
                        transfer_size);
 
                args = make_expression_list(dest, transfer_size);
            } break;
        case dma_load:
        case dma_store:
            /* Generate communication functions: */
            {
                //if(!scalar_entity) {
                /* Build the sizes of the array block to transfer: */
                list /*of expressions*/ transfer_sizes = NIL;
                FOREACH(DIMENSION,d,ld) {
                    expression transfer_size=
                        SizeOfDimension(d);
                    transfer_sizes=CONS(EXPRESSION,transfer_size,transfer_sizes);
                }
                transfer_sizes=gen_nreverse(transfer_sizes);
 
                /* Build the sizes of the array with element to transfer: */
                list/* of expressions*/ from_dims = NIL;
                list vardims = variable_to_dimensions(reg_from);
                FOREACH(DIMENSION,d, vardims) {
                    from_dims=CONS(EXPRESSION,SizeOfDimension(d),from_dims);
                }
                gen_full_free_list(vardims);
                from_dims=gen_nreverse(from_dims);
 
                /* Build the offsets of the array block to transfer: */
                list/* of expressions*/ offsets = NIL;
                FOREACH(EXPRESSION,e,lo)
                    offsets=CONS(EXPRESSION,e,offsets);
                offsets=gen_nreverse(offsets);
                /* Use a special transfert function for scalars instead of reusing
                   the 1D function. It may useful for example if it is implemented
                   as a FIFO at the hardware level: */
                //} else {
                //    /* If we have a scalar variable to transfert, generate
                //       synthetic transfer parameters: */
                //    /* 1 element to transfert */
                //    transfer_sizes = make_expression_list(int_to_expression(1));
                //    /* 1 dimension */
                //    from_dims = make_expression_list(int_to_expression(1));
                //    /* At the begining of the « array »: */
                //    offsets = make_expression_list(int_to_expression(0));
                //  }
 
                expression source = region_to_address(reg_from);
                /* Generate host and accel adresses: */
                args = CONS(EXPRESSION,source,CONS(EXPRESSION,dest,NIL));
                //if(dma_load_p(m))
                //    args=gen_nreverse(args);
                /* Output parameters in an order compatible with some C99
                   implementation of the runtime: size and block size first, so
                   that some arguments can be defined with them: */
                /* Insert offset: */
                args = gen_append(offsets, args);
                /* Insert the block size to transfert: */
                args = gen_append(transfer_sizes, args);
                /* Insert the array sizes: */
                args = gen_append(from_dims, args);
                /* Insert the element size expression: */
                expression sizeof_exp = get_sizeofexpression_for_region(reg_from);
                args = CONS(EXPRESSION,
                        sizeof_exp,
                        args);
            } break;
        default:
            pips_internal_error("should not happen");
    }
    return make_call(mcpy, args);
}

References AddEntityToModule(), AddEntityToModuleCompilationUnit(), ADDRESS_OF_OPERATOR_NAME, CONS, copy_language(), DEREFERENCING_OPERATOR_NAME, DIMENSION, dma_allocate, dma_allocate_p, dma_deallocate, dma_deallocate_p, dma_load, dma_store, entity_intrinsic(), entity_scalar_p(), entity_to_expression(), entity_undefined_p, EXPRESSION, FOREACH, fortran_module_p(), gen_append(), gen_full_free_list(), gen_nreverse(), get_current_module_entity(), get_dma_dimension(), get_dma_name(), get_sizeofexpression_for_region(), make_basic_pointer(), make_call(), make_cast(), make_empty_subroutine(), make_expression(), make_expression_list, make_syntax_cast(), make_type_variable(), make_type_void(), make_variable(), MakeBinaryCall(), MakeUnaryCall(), module_language, module_name_to_entity(), MULTIPLY_OPERATOR_NAME, NIL, normalized_undefined, pips_internal_error, pips_user_warning, reference_variable, region_any_reference, region_to_address(), SizeOfDimension(), SizeOfDimensions(), and variable_to_dimensions().

Referenced by effects_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

do_check_isolate_statement_preconditions_on_call()

static bool do_check_isolate_statement_preconditions_on_call ( call  c, param_t *  p  )

static

get parent statement

get associated regions

verify the conditions : no complex offset handling

we are left with a scalar or an unidimensional array

we can do it! leave it for later

The following test could be refined, but it is OK right now if we can override it with the following property when generating code for GPU for example.

Should not return from previous exception anyway...

Definition at line 841 of file isolate_statement.c.

                                                                                 {
    if(same_string_p(entity_local_name(call_function(c)),p->callee_module_name)) {
        /* get parent statement */
        statement s = (statement)gen_get_ancestor(statement_domain,c);
        pips_assert("found ancestor",!statement_undefined_p(s));
        /* get associated regions */
        list regions = load_cumulated_rw_effects_list(s);
        /* verify the conditions : no complex offset handling */
        FOREACH(REGION,reg,regions) {
            reference ref = region_any_reference(reg);
            entity eref = reference_variable(ref);
            list indices = reference_indices(ref);
            size_t nbdims;
            type ut = ultimate_type(entity_type(eref));
            if(type_pointer_on_struct_variable_p(ut))
                nbdims = gen_length(variable_dimensions(type_variable(ut)));
            else if(pointer_type_p(ut))
                nbdims = gen_length(indices);
            else
                nbdims = gen_length(variable_dimensions(type_variable(ut)));
            if(nbdims>1) { // unhandled
                pips_user_warning("Trying to isolate a statement with a call that touches a multi-dimensional array `%s'\n", entity_user_name(eref));
                p->ok=false;
            }
            /* we are left with a scalar or an unidimensional array */
            else if(nbdims==1 && !ENDP(indices) ) { // see if we can approximate the region with an offset at zero
                expression exp_phi1 = EXPRESSION(CAR(indices));
                entity phi1 = expression_to_entity(exp_phi1);
                Psysteme sc_reg = sc_dup(region_system(reg));
                sc_transform_eg_in_ineg(sc_reg);
                Pcontrainte lower,upper;
                constraints_for_bounds(phi1,
                        &sc_inegalites(sc_reg), &lower, &upper);
                if( !CONTRAINTE_UNDEFINED_P(upper))
                {
                    expression eupper = constraints_to_loop_bound(upper,phi1,false,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                    normalized nupper = NORMALIZE_EXPRESSION(eupper);
                    if(normalized_linear_p(nupper)) {
                        /* we can do it! leave it for later */
                        p->regions_to_extend = CONS(ENTITY, eref, p->regions_to_extend);
                    }
                    else {
                        pips_user_warning("Failed to normalized the upper bound for accesses to array `%s'\n",entity_user_name(eref));
                        p->ok=false;
                    }
                    free_expression(eupper);
 
                }
                else {
                    pips_user_warning("Failed to find an upper bound for accesses to array `%s'\n",entity_user_name(eref));
                    p->ok=false;
                }
                contrainte_rm(lower);
                contrainte_rm(upper);
                sc_rm(sc_reg);
            }
            if(!p->ok) {
                gen_recurse_stop(0);
                return false;
            }
        }
 
        // verify the call does not references globals
        list summary_regions = effects_to_list((effects)db_get_memory_resource(DBR_SUMMARY_REGIONS, p->callee_module_name, true));
        FOREACH(REGION, sr, summary_regions) {
            reference ref = region_any_reference(sr);
            entity eref = reference_variable(ref);
            if(!entity_local_variable_p(eref,get_current_module_entity()) && ! formal_parameter_p(eref) ) {
                /* The following test could be refined, but it is OK right now if we can
                   override it with the following property when generating code for GPU
                   for example. */
                if (!get_bool_property("ISOLATE_STATEMENT_EVEN_NON_LOCAL") &&
                        !io_effect_p(sr) && !std_file_effect_p(sr) ) {
                    pips_user_error("Cannot handle with some effects on non local variables in isolate_statement\n");
                    /* Should not return from previous exception anyway... */
                }
 
            }
        }
    }
 
    return true;
}

References call_function, param_t::callee_module_name, CAR, CONS, constraints_for_bounds(), constraints_to_loop_bound(), contrainte_rm, CONTRAINTE_UNDEFINED_P, db_get_memory_resource(), DIVIDE_OPERATOR_NAME, effects_to_list(), ENDP, ENTITY, entity_intrinsic(), entity_local_name(), entity_local_variable_p(), entity_type, entity_user_name(), EXPRESSION, expression_to_entity(), FOREACH, formal_parameter_p(), free_expression(), gen_get_ancestor(), gen_length(), gen_recurse_stop(), get_bool_property(), get_current_module_entity(), indices, io_effect_p(), load_cumulated_rw_effects_list(), NORMALIZE_EXPRESSION, normalized_linear_p, param_t::ok, pips_assert, pips_user_error, pips_user_warning, pointer_type_p(), ref, reference_indices, reference_variable, REGION, region_any_reference, region_system, param_t::regions_to_extend, same_string_p, sc_dup(), sc_rm(), sc_transform_eg_in_ineg(), statement_domain, statement_undefined_p, std_file_effect_p(), summary_regions(), type_pointer_on_struct_variable_p(), type_variable, ultimate_type(), and variable_dimensions.

Referenced by do_isolate_statement_preconditions_satisified_p().

Here is the call graph for this function:

Here is the caller graph for this function:

do_isolate_statement()

void do_isolate_statement	(	statement	s,
		const char *	prefix,
		const char *	suffix
	)

perform statement isolation on statement s that is make sure that all access to variables in s are made either on private variables or on new entities declared on a new memory space.

The prefix is used as a prefix to new entities' name.

this hash table holds an entity to (entity + tag ) binding

Add the calls now if needed, in the correct order:

guard the whole block by according conditions

prends ton couteau suisse et viens jouer avec moi dans pips

Parameters

prefix	refix
suffix	uffix

Definition at line 1018 of file isolate_statement.c.

                                                                               {
    bool fine_grain_analysis = true;
    statement allocates, loads, stores, deallocates;
    /* this hash table holds an entity to (entity + tag ) binding */
    hash_table e2e ;
    if(!do_isolate_statement_preconditions_satisified_p(s)) {
        pips_user_warning("isolated statement has callees, transfers will be approximated\n");
        fine_grain_analysis = false; // FIXME : This could be true most of the time, especially in Par4All !
    }
    e2e = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
    expression condition = expression_undefined;
    allocates = effects_to_dma(s,dma_allocate,e2e,&condition,
            fine_grain_analysis,prefix,suffix);
    loads = effects_to_dma(s,dma_load,e2e,NULL,fine_grain_analysis,prefix,
            suffix);
    stores = effects_to_dma(s,dma_store,e2e,NULL,fine_grain_analysis,prefix,
            suffix);
    deallocates = effects_to_dma(s,dma_deallocate,e2e,NULL,fine_grain_analysis,
            prefix,suffix);
    HASH_MAP(k,v,free(v),e2e);
    hash_table_free(e2e);
 
    /* Add the calls now if needed, in the correct order: */
    if (loads != statement_undefined)
        insert_statement(s, loads,true);
    if (stores != statement_undefined)
        insert_statement(s, stores,false);
    if (deallocates != statement_undefined)
        insert_statement(s, deallocates,false);
    if (allocates != statement_undefined)
        insert_statement(s, allocates,true);
    /* guard the whole block by according conditions */
    if(!expression_undefined_p(condition)) {
 
        /* prends ton couteau suisse et viens jouer avec moi dans pips */
        pips_assert("statement is a block",statement_block_p(s));
        for(list prev=NIL,iter=statement_block(s);!ENDP(iter);POP(iter)) {
            if(declaration_statement_p(STATEMENT(CAR(iter)))) prev=iter;
            else {
                pips_assert("there should be at least one declaration inserted by isolate_statement\n",!ENDP(prev));
                statement cond = 
                    instruction_to_statement(
                            make_instruction_test(
                                make_test(
                                    condition,
                                    make_block_statement(iter),
                                    make_empty_statement()
                                    )
                                )
                            );
                CDR(prev)=CONS(STATEMENT,cond,NIL);
                break;
            }
        }
    }
}

References CAR, CDR, CONS, declaration_statement_p(), dma_allocate, dma_deallocate, dma_load, dma_store, do_isolate_statement_preconditions_satisified_p(), effects_to_dma(), ENDP, expression_undefined, expression_undefined_p, free(), HASH_DEFAULT_SIZE, HASH_MAP, hash_pointer, hash_table_free(), hash_table_make(), insert_statement(), instruction_to_statement(), make_block_statement(), make_empty_statement, make_instruction_test(), make_test(), NIL, pips_assert, pips_user_warning, POP, prefix, STATEMENT, statement_block(), statement_block_p, and statement_undefined.

Referenced by isolate_statement(), and kernel_load_store_generator().

Here is the call graph for this function:

Here is the caller graph for this function:

do_isolate_statement_preconditions_satisified_p()

static bool do_isolate_statement_preconditions_satisified_p ( statement  s )

static

we have to make sure every callee access no global variables and that the associated regions has no offset

add a constraint 0 <= phi1 and the upperbound constraint

duplicate the region

add it to current region

prune out read effects on pointers ... the assumption is that reading a pointer is not that important and most certainly comes from passing a pointer as parameter to a function if the pointer itself is not written, it should be ok. Well this indeed very optimistic ...

Definition at line 925 of file isolate_statement.c.

{
    callees c = compute_callees(s);
    list thecallees = callees_callees(c);
    /* we have to make sure every callee access no global variables and that
     * the associated regions has no offset
     */
    param_t p = { .ok=true, .regions_to_extend=NIL };
    FOREACH(STRING, callee_module_name, thecallees) {
        p.callee_module_name=callee_module_name;
        gen_context_recurse(s,&p,call_domain,do_check_isolate_statement_preconditions_on_call,gen_null2);
        if(!p.ok) break;
    }
    free_callees(c);
    if(p.ok) { // this mean that all checks are ok, but some patching is needed
        // maybe we have registered some regions to extend to avoid interprocedural offset management?
        list regions = load_cumulated_rw_effects_list(s);
        FOREACH(ENTITY,e,p.regions_to_extend) {
            for(list iter=regions;!ENDP(iter);POP(iter)){ // change the region in place, thus the refcar
                region * reg = (region*)REFCAR(iter);
                reference ref = region_any_reference(*reg);
                list indices = reference_indices(ref);
                if(!ENDP(indices)) { // only entities with indices are considered
                    entity eref = reference_variable(ref);
                    if(same_entity_p(eref,e)) { // we got the right entity
                        expression exp_phi1 = EXPRESSION(CAR(indices));
                        entity phi1 = expression_to_entity(exp_phi1);
                        Psysteme sc_reg = sc_dup(region_system(*reg));
                        sc_transform_eg_in_ineg(sc_reg);
                        Pcontrainte lower,upper;
                        constraints_for_bounds(phi1,
                                &sc_inegalites(sc_reg), &lower, &upper);
                        if( !CONTRAINTE_UNDEFINED_P(upper))
                        {
                            expression eupper = constraints_to_loop_bound(upper,phi1,false,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                            normalized nupper = NORMALIZE_EXPRESSION(eupper);
                            if(normalized_linear_p(nupper)) {
                                Psysteme sc =sc_new();
                                /* add a constraint 0 <= phi1 and the upperbound constraint*/
                                sc_add_phi_equation(&sc, int_to_expression(0), 1, false, false);
                                sc_add_phi_equation(&sc, eupper, 1, false, true);
 
                                bool must = false;
                                if(!CONTRAINTE_UNDEFINED_P(lower)) {
                                    expression elower = constraints_to_loop_bound(lower,phi1,true,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                                    intptr_t p;
                                    must=(expression_integer_value(elower,&p)&&p==0);
                                    free_expression(elower);
                                }
                                /* duplicate the region */
                                region copy = make_region(copy_reference(ref),
                                        copy_action(region_action(*reg)),
                                        must?make_approximation_exact():make_approximation_may(), sc);
                                /* add it to current region */
                                region nreg = extended_regions_must_convex_hull(*reg,copy);
                                //free_effect(*reg);
                                //free_effect(copy);
                                *reg=nreg;
                            }
                            else pips_internal_error("This case should have been filtered out by `do_check_isolate_statement_preconditions_on_call'");
                        }
                        else pips_internal_error("This case should have been filtered out by `do_check_isolate_statement_preconditions_on_call'");
                    }
                }
            }
        }
        /* prune out read effects on pointers ...
         * the assumption is that reading a pointer is not that important and most certainly comes from passing a pointer as parameter to a function
         * if the pointer itself is not written, it should be ok.
         * Well this indeed very optimistic ...
         */
        list rdup = gen_copy_seq(regions);
        FOREACH(REGION,r,rdup) {
            if(region_read_p(r) ) {
                reference ref = region_any_reference(r);
                if(entity_pointer_p(reference_variable(ref)) && 
                        ENDP(reference_indices(ref))) {
                    gen_remove_once(&regions,r);
                }
            }
        }
        update_cumulated_rw_effects_list(s,regions);
        gen_free_list(rdup);
        gen_free_list(p.regions_to_extend);
    }
    return p.ok;
}

References call_domain, param_t::callee_module_name, callees_callees, CAR, compute_callees(), constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED_P, copy_action(), copy_reference(), DIVIDE_OPERATOR_NAME, do_check_isolate_statement_preconditions_on_call(), ENDP, ENTITY, entity_intrinsic(), entity_pointer_p(), EXPRESSION, expression_integer_value(), expression_to_entity(), extended_regions_must_convex_hull(), FOREACH, free_callees(), free_expression(), gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_null2(), gen_remove_once(), indices, int_to_expression(), intptr_t, load_cumulated_rw_effects_list(), make_approximation_exact(), make_approximation_may(), make_region, NIL, NORMALIZE_EXPRESSION, normalized_linear_p, param_t::ok, pips_internal_error, POP, ref, REFCAR, reference_indices, reference_variable, region, REGION, region_action, region_any_reference, region_read_p, region_system, param_t::regions_to_extend, same_entity_p(), sc_add_phi_equation(), sc_dup(), sc_new(), sc_transform_eg_in_ineg(), STRING, and update_cumulated_rw_effects_list().

Referenced by do_isolate_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_to_dma()

static statement effects_to_dma ( statement  stat, enum region_to_dma_switch  s, hash_table  e2e, expression *  condition, bool  fine_grain_analysis, const char *  prefix, const char *  suffix  )

static

Compute a call to a DMA function from the effects of a statement.

Parameters

[in]	stat	is the statement we want to generate communication operations for
[in]	prefix	is the prefix to be used for added variable. operations for

Returns

a statement of the DMA transfers or statement_undefined if nothing is needed or if the dma function has been set to "" in the relevant property

If this cannot be done, it throws a pips_user_error

if no dma is provided, skip the computation it is used for scalope at least

work on a copy because we compute the rectangular hull in place and keep only store effects: we do not care for environment effects here (BC)

free the spine, as effects are shared with the database

ensure we only have a rectangular region as a side effect, strided accesses are handled by region_rectangular_hull

merge copy in and copy out for allocation this is entity-based, we could do a better job if we were reference-based

merge regions with same prefix but different suffixes (in presence of fields ...)

SG: to do: merge convex hulls when they refer to all fields of a region to do this, according to BC, I should iterate over all regions, detect fields and then iterate again over regions to find combinable regions that way I would not generate needless read effects when all fields are accessed using the same pattern

some more dev I am not willing to do right now :)

filter out relevant effects depending on operation mode

if we failed to provide a fine_grain_analysis, we can still rely on the definition region to over approximate the result

handle the may approximations here: if the approximation is may, we have to load the data, otherwise the store may store irrelevant data

first step is to check for may-write effects

then we will merge these effects with those that were already gathered because we are manipulating lists, it is not very efficient but there should not be that many effects anyway

no data was copy-in, add this effect

builds out transfer from gathered effects

f dimensions

f expressions

initialized with NULL value

Replace the reference to the array re to *eto:

o avoid duplicate

Definition at line 580 of file isolate_statement.c.

{
    /* if no dma is provided, skip the computation
     * it is used for scalope at least */
    if(empty_string_p(get_dma_name(s,dma1D)))
        return statement_undefined;
 
    /* work on a copy because we compute the rectangular hull in place
       and keep only store effects: we do not care for environment effects here (BC)
       */
    list l_eff_tmp = effects_store_effects(load_cumulated_rw_effects_list(stat));
    list rw_effects = gen_full_copy_list(l_eff_tmp);
    gen_free_list(l_eff_tmp); /* free the spine, as effects are shared with the database */
    transformer tr = transformer_range(load_statement_precondition(stat));
 
    /* ensure we only have a rectangular region
     * as a side effect, strided accesses are handled by region_rectangular_hull
     */
    for(list iter = rw_effects;!ENDP(iter);POP(iter)) {
        region *tmp = (region*)REFCAR(iter);
        region new = region_rectangular_hull(*tmp,true);
        //    free_effect(*tmp); SG: why does this lead to a segfault ?
        //    I find no sharing in region_rectangular_hull
        *tmp=new;
    }
 
    /* merge copy in and copy out for allocation
     * this is entity-based, we could do a better job if we were reference-based 
     */
    if (dma_allocate_p(s) || dma_deallocate_p(s)) {
        list out = NIL;
        set visited_entities = set_make(set_pointer);
        FOREACH(EFFECT,self,rw_effects) {
            entity svar = reference_variable(region_any_reference(self));
            if(!set_belong_p(visited_entities,svar)) {
                set_add_element(visited_entities, visited_entities, svar);
                FOREACH(EFFECT,other, rw_effects) {
                    if(self!=other) {
                        entity ovar = reference_variable(region_any_reference(other));
                        if(same_entity_p(svar,ovar)) {
                            effect etmp = extended_regions_must_convex_hull(self,other);
                            if(region_write_p(other))
                                region_action(etmp) = copy_action(region_action(other));
                            //free_effect(self);
                            self=etmp;
                        }
                    }
                }
                out=CONS(EFFECT,self,out);
            }
        }
        set_free(visited_entities);
        gen_free_list(rw_effects);
        rw_effects=gen_nreverse(out);
    }
    /* merge regions with same prefix but different suffixes (in presence of fields ...) */
    if (dma_load_p(s) || dma_store_p(s) || dma_allocate_p(s) ) {
        list out = NIL;
        set r_visited_entities = set_make(set_pointer);
        set w_visited_entities = set_make(set_pointer);
        FOREACH(EFFECT,self, rw_effects) {
            entity svar = reference_variable(region_any_reference(self));
            enum action_utype sa = action_tag(region_action(self));
            set this = is_action_read ==sa ? r_visited_entities : w_visited_entities;
            if(!set_belong_p(this ,svar)) {
                set_add_element(this, this, svar);
                FOREACH(EFFECT,other,rw_effects) {
                    if(self!=other) {
                        entity ovar = reference_variable(region_any_reference(other));
                        if(same_entity_p(svar,ovar) && (sa == action_tag(region_action(other))) ) {
                            effect etmp = extended_regions_must_convex_hull(self,other);
                            //free_effect(self);
                            self=etmp;
                        }
                    }
                }
                out=CONS(EFFECT,self,out);
            }
        }
        set_free(r_visited_entities);
        set_free(w_visited_entities);
        gen_free_list(rw_effects);
        rw_effects=gen_nreverse(out);
    }
 
    /* SG: to do: merge convex hulls when they refer to *all* fields of a region
     * to do this, according to BC, I should iterate over all regions,
     * detect fields and then iterate again over regions to find combinable regions
     * that way I would not generate needless read effects when all fields are accessed using the same pattern
     *
     * some more dev I am not willing to do right now :)
     */
 
 
    list effects = NIL;
 
    /* filter out relevant effects depending on operation mode */
    FOREACH(EFFECT,e,rw_effects) {
        if ((dma_load_p(s) || dma_allocate_p(s) || dma_deallocate_p(s))
                && action_read_p(effect_action(e)))
            effects=CONS(EFFECT,e,effects);
        else if ((dma_store_p(s)  || dma_allocate_p(s) || dma_deallocate_p(s))
                && action_write_p(effect_action(e)))
            effects=CONS(EFFECT,e,effects);
    }
    effects=gen_nreverse(effects);
 
 
    /* if we failed to provide a fine_grain_analysis, we can still rely on the definition region to over approximate the result
    */
    if(!fine_grain_analysis) {
        FOREACH(EFFECT,eff,rw_effects) {
            if(entity_pointer_p(reference_variable(region_any_reference(eff)))
                    && ! std_file_effect_p(eff)) {
              print_effect(eff);
              pips_user_error("pointers wreak havoc with isolate_statement\n");
            }
            descriptor d = effect_descriptor(eff);
            if(descriptor_convex_p(d)) {
                Psysteme sc_old = descriptor_convex(d);
                Psysteme sc_new = entity_declaration_sc(reference_variable(region_any_reference(eff)));
                sc_intersection(sc_new,sc_new,predicate_system(transformer_relation(tr)));
                sc_intersection(sc_old,sc_old,predicate_system(transformer_relation(tr)));
                sc_old=sc_normalize2(sc_old);
                sc_new=sc_normalize2(sc_new);
                if(!sc_equal_p(sc_old,sc_new)) {
                    sc_free(sc_old);
                    descriptor_convex(d)=sc_new;
                    effect_approximation_tag(eff)=is_approximation_may;
                }
            }
        }
    }
 
    /* handle the may approximations here: if the approximation is may,
     * we have to load the data, otherwise the store may store
     * irrelevant data
     */
    if (dma_load_p(s) || dma_allocate_p(s) || dma_deallocate_p(s)) {
        /* first step is to check for may-write effects */
        list may_write_effects = NIL;
        FOREACH(EFFECT,e,rw_effects) {
            if(approximation_may_p(effect_approximation(e)) &&
                    action_write_p(effect_action(e)) ) {
                effect fake = copy_effect(e);
                action_tag(effect_action(fake))=is_action_read;
                may_write_effects=CONS(EFFECT,fake,may_write_effects);
            }
        }
        may_write_effects=gen_nreverse(may_write_effects);
        /* then we will merge these effects with those
         * that were already gathered
         * because we are manipulating lists, it is not very efficient
         * but there should not be that many effects anyway
         */
        FOREACH(EFFECT,e_new,may_write_effects) {
            bool merged = false; // if we failed to merge e_new in effects, we just add it to the list */
            for(list iter=effects;!ENDP(iter);POP(iter)){
                effect * e_origin = (effect*)REFCAR(iter); // get a reference to change it in place if needed
                if(same_entity_p(
                            effect_any_entity(*e_origin),
                            effect_any_entity(e_new))) {
                    merged=true;
                    region tmp = extended_regions_must_convex_hull(*e_origin,e_new);
                    // there should be a free there, but it fails
                    *e_origin=tmp;
                }
            }
            /* no data was copy-in, add this effect */
            if(!merged) {
                effects=CONS(EFFECT,copy_effect(e_new),effects);
            }
        }
        gen_full_free_list(may_write_effects);
        effects=gen_nreverse(effects);
    }
 
 
 
    /* builds out transfer from gathered effects */
    list statements = NIL;
    FOREACH(EFFECT,eff,effects) {
        statement the_dma = statement_undefined;
        reference r = effect_any_reference(eff);
        entity re = reference_variable(r);
 
        if(entity_abstract_location_p(re)) {
            pips_user_error("We can't handle abstract locations here. Please try to "
                    "avoid using pointer or activate some pointer analyzes.\n");
        }
 
 
        struct dma_pair * val = (struct dma_pair *) hash_get(e2e, re);
 
        if( val == HASH_UNDEFINED_VALUE || (val->s != s) ) {
            if( !io_effect_p(eff) && !std_file_effect_p(eff) &&
                    (!entity_scalar_p(re) || get_bool_property("KERNEL_LOAD_STORE_SCALAR"))
              ) {
                list /*of dimensions*/ the_dims = NIL,
                     /*of expressions*/the_offsets = NIL;
                region_to_dimensions(eff,tr,&the_dims,&the_offsets,condition);
 
                entity eto;
                if(val == HASH_UNDEFINED_VALUE) {
 
                    /* initialized with NULL value */
                    expression init = int_to_expression(0);
 
                    /* Replace the reference to the array re to *eto: */
                    type re_type = ultimate_array_type(entity_type(re));
                    basic re_basic = basic_undefined;
                    pips_assert("the type of the considered effect is expected to be variable",
                            type_variable_p(re_type));
                    re_basic = variable_basic(type_variable(re_type));
                    if(basic_pointer_p(re_basic)) {
                        type pointed_type = basic_pointer(re_basic);
                        re_basic = variable_basic(type_variable(pointed_type));
                    }
                    entity renew = make_new_array_variable(get_current_module_entity(),copy_basic(re_basic),the_dims);
                    entity declaring_module =
                        get_current_module_entity();
                    // PIER Here we need to add a P4A variable prefix to the name to help
                    // p4a postprocessing
                    string str = strdup (concatenate (prefix,entity_user_name(re), suffix, NULL));
                    eto = make_temporary_pointer_to_array_entity_with_prefix(str,renew,declaring_module,init);
                    free (str);
                    AddLocalEntityToDeclarations(eto,get_current_module_entity(),stat);
                    isolate_patch_entities(stat,re,eto,the_offsets);
 
                    val=malloc(sizeof(*val));
                    val->new_ent=eto;
                    val->s=s;
                    hash_put(e2e,re,val);
                }
                else {
                    eto = val->new_ent;
                    val->s=s;/*to avoid duplicate*/
                }
                the_dma = instruction_to_statement(make_instruction_call(dimensions_to_dma(eff,eto,the_dims,the_offsets,s)));
                statements=CONS(STATEMENT,the_dma,statements);
            }
        }
    }
    gen_free_list(effects);
    gen_full_free_list(rw_effects);
    if (statements == NIL)
        return statement_undefined;
    else
        return make_block_statement(statements);
}

References action_read_p, action_tag, action_write_p, AddLocalEntityToDeclarations(), approximation_may_p, basic_pointer, basic_pointer_p, basic_undefined, concatenate(), CONS, copy_action(), copy_basic(), copy_effect(), descriptor_convex, descriptor_convex_p, dimensions_to_dma(), dma1D, dma_allocate_p, dma_deallocate_p, dma_load_p, dma_store_p, EFFECT, effect_action, effect_any_entity, effect_any_reference, effect_approximation, effect_approximation_tag, effect_descriptor, effects_store_effects(), empty_string_p(), ENDP, entity_abstract_location_p(), entity_declaration_sc(), entity_pointer_p(), entity_scalar_p(), entity_type, entity_user_name(), extended_regions_must_convex_hull(), FOREACH, free(), gen_free_list(), gen_full_copy_list(), gen_full_free_list(), gen_nreverse(), get_bool_property(), get_current_module_entity(), get_dma_name(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, init, instruction_to_statement(), int_to_expression(), io_effect_p(), is_action_read, is_approximation_may, isolate_patch_entities(), load_cumulated_rw_effects_list(), load_statement_precondition(), make_block_statement(), make_instruction_call(), make_new_array_variable(), make_temporary_pointer_to_array_entity_with_prefix(), malloc(), dma_pair::new_ent, NIL, out, pips_assert, pips_user_error, pointed_type(), POP, predicate_system, prefix, print_effect, REFCAR, reference_variable, region, region_action, region_any_reference, region_rectangular_hull(), region_to_dimensions(), region_write_p, dma_pair::s, same_entity_p(), sc_equal_p, sc_free(), sc_intersection(), sc_new(), sc_normalize2(), set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, STATEMENT, statement_undefined, std_file_effect_p(), strdup(), transformer_range(), transformer_relation, type_variable, type_variable_p, ultimate_array_type(), and variable_basic.

Referenced by do_isolate_statement().

Here is the caller graph for this function:

extended_regions_must_convex_hull()

static region extended_regions_must_convex_hull ( region  r0, region  r1  )

static

perform the convex hull between r0 and r1, and merge them if they have a common prefix e.g.

a[phi1].re[phi2] U_ex a[phi3].im[phi4] = a[phi1] U_may a[phi3]

Definition at line 530 of file isolate_statement.c.

                                                               {
    list i0 = reference_indices(region_any_reference(r0)),
         i1 = reference_indices(region_any_reference(r1));
    list n0 = NIL, n1=NIL;
    while(!ENDP(i0)&&!ENDP(i1)) {
        expression e0 = EXPRESSION(CAR(i0)),
                   e1 = EXPRESSION(CAR(i1));
        // stop there: we have found the common prefix
        if(expression_reference_p(e0) && entity_field_p(reference_variable(expression_reference(e0))) &&
                expression_reference_p(e1) && entity_field_p(reference_variable(expression_reference(e1))) ) {
            n0=gen_nreverse(n0);
            n1=gen_nreverse(n1);
            list t0 = reference_indices(region_any_reference(r0)),
                 t1 = reference_indices(region_any_reference(r1));
            reference_indices(region_any_reference(r0)) = n0;
            reference_indices(region_any_reference(r1)) = n1;
            region out = regions_must_convex_hull(r0, r1);
            region_approximation_tag(out)=is_approximation_may; // better pessimistic than nothing.
            reference_indices(region_any_reference(r0)) = t0;
            reference_indices(region_any_reference(r1)) = t1;
            gen_free_list(n0);
            gen_free_list(n1);
            return out;
        }
        // else keep on pushing
        n0=CONS(EXPRESSION,e0,n0);
        n1=CONS(EXPRESSION,e1,n1);
        POP(i0);
        POP(i1);
    }
    gen_free_list(n0);
    gen_free_list(n1);
    return regions_must_convex_hull(r0, r1);
 
}

References CAR, CONS, ENDP, entity_field_p(), EXPRESSION, expression_reference(), expression_reference_p(), gen_free_list(), gen_nreverse(), is_approximation_may, NIL, out, POP, reference_indices, reference_variable, region, region_any_reference, region_approximation_tag, and regions_must_convex_hull().

Referenced by do_isolate_statement_preconditions_satisified_p(), and effects_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

find_region_on_entity()

region find_region_on_entity	(	entity	e,
		list	regions
	)

Returns

region from regions on entity e

Parameters

regions

egions

Definition at line 1325 of file isolate_statement.c.

{
    FOREACH(REGION,r,regions)
        if(same_entity_p(e,reference_variable(region_any_reference(r)))) return r;
    return region_undefined;
}

References FOREACH, reference_variable, REGION, region_any_reference, region_undefined, and same_entity_p().

Referenced by do_solve_hardware_constraints_on_nb_proc(), and do_solve_hardware_constraints_on_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dma_dimension()

static size_t get_dma_dimension ( region  reg_from )

static

It should be the number of variable phis and stop at first field

Definition at line 79 of file isolate_statement.c.

                                                 {
    /* It should be the number of variable phis and stop at first field*/
    size_t n=0;
    FOREACH(EXPRESSION,exp,reference_indices(region_any_reference(reg_from))) {
        if(expression_reference_p(exp)) {
            reference ref = expression_reference(exp);
            entity var = reference_variable(ref);
            if(variable_phi_p(var) ) {
                    ++n;
            }
            else {
                pips_assert("not a  phi means a field",entity_field_p(var));
                break;
            }
        }
    }
    return n;
}

References entity_field_p(), exp, EXPRESSION, expression_reference(), expression_reference_p(), FOREACH, pips_assert, ref, reference_indices, reference_variable, region_any_reference, and variable_phi_p.

Referenced by dimensions_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dma_name()

static const char* get_dma_name ( enum region_to_dma_switch  m, size_t  d  )

static

converts a region_to_dma_switch to corresponding dma name according to properties

If the DMA is not scalar, the DMA function name is in the property of the form KERNEL_LOAD_STORE_LOAD/STORE_FUNCTION_dD:

not scalar

Definition at line 102 of file isolate_statement.c.

                                                                       {
    const char *seeds[] = {
        "KERNEL_LOAD_STORE_LOAD_FUNCTION",
        "KERNEL_LOAD_STORE_STORE_FUNCTION",
        "KERNEL_LOAD_STORE_ALLOCATE_FUNCTION",
        "KERNEL_LOAD_STORE_DEALLOCATE_FUNCTION"
    };
    const char * propname = seeds[(int)m];
    /* If the DMA is not scalar, the DMA function name is in the property
       of the form KERNEL_LOAD_STORE_LOAD/STORE_FUNCTION_dD: */
    char * apropname= NULL;
    if(d > 0 /* not scalar*/ && (int)m < 2)
        asprintf(&apropname,"%s_%dD", seeds[(int)m], (int)d);
    const char* dmaname = get_string_property(apropname?apropname:propname);
    if(apropname) free(apropname);
    return dmaname;
}

References asprintf, free(), get_string_property(), and int.

Referenced by dimensions_to_dma(), and effects_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

get_sizeofexpression_for_region()

static expression get_sizeofexpression_for_region ( region  reg )

static

generate an expression of the form sizeof(typeof(variable[indices]))

It also handles the fields: fields reference are converted to proper expression then an approximation is made to ensure there is no stride e.g struct { int x,y; } a [10]; a[1][x] -> sizeof(a[1]) struct { int x[10], y[10] } a; a[x][1] -> sizeof(a.x)

extract the constant indices of the region

Here we make a special case for struct because of nvcc/C++ doesn't like construct like : sizeof(struct {data_t latitude; data_t longitude; data_t stock;}) so we produce a sizeof(var); instead

Definition at line 280 of file isolate_statement.c.

                                                              {
    expression sizeof_exp;
    reference rr = region_any_reference(reg);
 
    reference r = make_reference(reference_variable(rr),NIL);
 
    /* extract the constant indices of the region */
    FOREACH(EXPRESSION,exp, reference_indices(rr)) {
        pips_assert("region indices are only references",expression_reference_p(exp)) ;
        reference ref = expression_reference(exp);
        entity var = reference_variable(ref);
        if(entity_field_p(var)) {
            break;
        }
        else if(variable_phi_p(var)) {
                reference_indices(r)=CONS(EXPRESSION,int_to_expression(0),reference_indices(r));
        }
        else pips_internal_error("not a field and not a phi variable ?");
    }
    reference_indices(r)= gen_nreverse(reference_indices(r));
 
    type element_type = make_type_variable(make_variable(basic_of_reference(r),
                NIL,
                NIL));
 
    /* Here we make a special case for struct because of nvcc/C++ doesn't like construct like :
     *  sizeof(struct {data_t latitude; data_t longitude; data_t stock;})
     * so we produce a sizeof(var); instead
     */
    if(type_struct_variable_p(element_type)) {
        expression exp = region_reference_to_expression(r);
        sizeof_exp = MakeSizeofExpression(exp);
        free_type(element_type);
    } else {
        sizeof_exp = MakeSizeofType(element_type);
    }
    return sizeof_exp;
}

References basic_of_reference(), CONS, entity_field_p(), exp, EXPRESSION, expression_reference(), expression_reference_p(), FOREACH, free_type(), gen_nreverse(), int_to_expression(), make_reference(), make_type_variable(), make_variable(), MakeSizeofExpression(), MakeSizeofType(), NIL, pips_assert, pips_internal_error, ref, reference_indices, reference_variable, region_any_reference, region_reference_to_expression(), type_struct_variable_p(), and variable_phi_p.

Referenced by dimensions_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_patch_entities()

void isolate_patch_entities	(	void *	where,
		entity	old,
		entity	new,
		list	offsets
	)

replace all references on entity old by references on entity new and adds offset offsets to its indices

Parameters

where	here
old	ld
new	ew
offsets	ffsets

Definition at line 1148 of file isolate_statement.c.

{
    isolate_param p = { old,new,offsets };
    gen_context_multi_recurse(where,&p,
            reference_domain,gen_true,isolate_patch_reference,
            statement_domain,gen_true,isolate_patch_statement,
            0);
}

References gen_context_multi_recurse(), gen_true(), isolate_patch_reference(), isolate_patch_statement(), reference_domain, and statement_domain.

Referenced by effects_to_dma(), and isolate_patch_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_patch_reference()

static void isolate_patch_reference ( reference  r, isolate_param *  p  )

static

replace reference r on entity p->old by a reference on entity p->new with offsets p->offsets

build up the replacement

it is illegal to create a subscript without indices quoting RK, at the airport back from SC 2010

Definition at line 1084 of file isolate_statement.c.

{
    if(same_entity_p(reference_variable(r),p->old))
    {
        list offsets = p->offsets;
        list indices = reference_indices(r);
        FOREACH(EXPRESSION,index,indices)
        {
            if(!ENDP(offsets)) {
                expression offset = EXPRESSION(CAR(offsets));
                if(!expression_reference_p(offset) || !entity_field_p(reference_variable(expression_reference(offset)))){
                    update_expression_syntax(index,
                            make_syntax_call(
                                make_call(
                                    entity_intrinsic(MINUS_OPERATOR_NAME),
                                    make_expression_list(
                                        copy_expression(index),
                                        copy_expression(offset)
                                        )
                                    )
                                )
                            );
                }
                POP(offsets);
            }
        }
        /* build up the replacement */
        syntax syn = 
            make_syntax_call(
                    make_call(
                        entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
                        CONS(EXPRESSION,entity_to_expression(p->new),NIL)
                        )
                    );
 
        /* it is illegal to create a subscript without indices
         * quoting RK, at the airport back from SC 2010 */
        syntax snew = ENDP(indices) ?
            syn:
            make_syntax_subscript(
                    make_subscript(syntax_to_expression(syn),indices)
                    );
        expression parent = (expression)gen_get_ancestor(expression_domain,r);
        expression_syntax(parent)=syntax_undefined;
        update_expression_syntax(parent,snew);
 
    }
}

References CAR, CONS, copy_expression(), DEREFERENCING_OPERATOR_NAME, ENDP, entity_field_p(), entity_intrinsic(), entity_to_expression(), EXPRESSION, expression_domain, expression_reference(), expression_reference_p(), expression_syntax, FOREACH, gen_get_ancestor(), indices, make_call(), make_expression_list, make_subscript(), make_syntax_call(), make_syntax_subscript(), MINUS_OPERATOR_NAME, isolate_param::new, NIL, offset, isolate_param::offsets, isolate_param::old, POP, reference_indices, reference_variable, same_entity_p(), syntax_to_expression(), syntax_undefined, and update_expression_syntax().

Referenced by isolate_patch_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_patch_statement()

static void isolate_patch_statement ( statement  s, isolate_param *  p  )

static

run isolate_patch_entities on all declared entities from s

Definition at line 1136 of file isolate_statement.c.

{
    FOREACH(ENTITY,e,statement_declarations(s))
    {
        if(!value_undefined_p(entity_initial(e)))
            isolate_patch_entities(entity_initial(e),p->old,p->new,p->offsets);
    }
}

References ENTITY, entity_initial, FOREACH, isolate_patch_entities(), isolate_param::new, isolate_param::offsets, isolate_param::old, statement_declarations, and value_undefined_p.

Referenced by isolate_patch_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_statement()

bool isolate_statement

(

const char *

module_name

)

Returns

a statement holding the loop necessary to initialize new from old, knowing the dimension of the isolated entity dimensions and its offsets offsets and the direction of the transfer t

init stuff

get user input

and proceed

validate

Parameters

module_name

odule_name

Definition at line 1349 of file isolate_statement.c.

{
    /* init stuff */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings(get_current_module_entity());
    set_precondition_map( (statement_mapping) db_get_memory_resource(DBR_PRECONDITIONS, module_name, true) );
 
 
    /* get user input */
    const char* stmt_label=get_string_property("ISOLATE_STATEMENT_LABEL");
    statement statement_to_isolate;
    if(!empty_string_p(stmt_label)) {
      statement_to_isolate = find_statement_from_label_name(get_current_module_statement(),get_current_module_name(),stmt_label);
    } else {
      statement_to_isolate = get_current_module_statement();
    }
    /* and proceed */
    if(statement_undefined_p(statement_to_isolate))
        pips_user_error("statement labeled '%s' not found\n",stmt_label);
    else
    {
        const char* prefix =  get_string_property ("ISOLATE_STATEMENT_VAR_PREFIX");
        const char* suffix =  get_string_property ("ISOLATE_STATEMENT_VAR_SUFFIX");
        pips_debug (5, "isolate_statement prefix : %s\n", prefix);
        pips_debug (5, "isolate_statement suffix : %s\n", suffix);
        do_isolate_statement(statement_to_isolate, prefix, suffix);
    }
 
 
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_precondition_map();
    free_value_mappings();
 
    return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_isolate_statement(), empty_string_p(), find_statement_from_label_name(), free_value_mappings(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), get_string_property(), module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), pips_debug, pips_user_error, prefix, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_precondition_map(), set_proper_rw_effects(), and statement_undefined_p.

Here is the call graph for this function:

lowerbound_of_expression()

static void lowerbound_of_expression ( expression  e, transformer  tr  )

static

replaces expression e by its lowerbound under preconditions tr

Definition at line 1188 of file isolate_statement.c.

{
    bounds_of_expression(e,tr,false);
}

References bounds_of_expression().

Referenced by region_to_minimal_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

region_to_address()

static expression region_to_address ( region  reg )

static

Definition at line 225 of file isolate_statement.c.

                                                {
    bool is_fortran = fortran_module_p(get_current_module_entity());
    int indice_first = (is_fortran == true) ? 1 : 0;
    expression address = entity_to_expression(reference_variable(region_any_reference(reg)));
    FOREACH(EXPRESSION,exp,reference_indices(region_any_reference(reg))) {
        pips_assert("region indices only contain references",expression_reference_p(exp));
        reference expr = expression_reference(exp);
        entity var =reference_variable(expr);
        if(variable_phi_p(var)) {
            expression index = int_to_expression(indice_first);
            if(expression_reference_p(address)) {
                reference_indices(expression_reference(address))=
                    gen_nconc(reference_indices(expression_reference(address)),
                        make_expression_list(index));
            }
            else 
            address= make_expression(
                    make_syntax_subscript(
                        make_subscript(address,make_expression_list(index))
                        )
                    ,
                    normalized_undefined
                    );
        }
        else {
            address= MakeBinaryCall(
                    entity_intrinsic(FIELD_OPERATOR_NAME),
                    address,
                    copy_expression(exp)
                    );
        }
    }
    expression result;
    if (fortran_module_p(get_current_module_entity()))
        result = MakeUnaryCall(entity_intrinsic(C_LOC_FUNCTION_NAME),
                address);
    else
        result = MakeUnaryCall(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),
                address);
    return result;
}

References ADDRESS_OF_OPERATOR_NAME, C_LOC_FUNCTION_NAME, copy_expression(), entity_intrinsic(), entity_to_expression(), exp, EXPRESSION, expression_reference(), expression_reference_p(), FIELD_OPERATOR_NAME, FOREACH, fortran_module_p(), gen_nconc(), get_current_module_entity(), int_to_expression(), make_expression(), make_expression_list, make_subscript(), make_syntax_subscript(), MakeBinaryCall(), MakeUnaryCall(), normalized_undefined, pips_assert, reference_indices, reference_variable, region_any_reference, and variable_phi_p.

Referenced by dimensions_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

region_to_dimensions()

void region_to_dimensions	(	effect	reg,
		transformer	tr,
		list *	dimensions,
		list *	offsets,
		expression *	condition
	)

isolate_statement.c

Parameters

reg	eg
tr	r
dimensions	imensions
offsets	ffsets
condition	ondition

Definition at line 204 of file isolate_statement.c.

                                                                                                               {
    pips_assert("effects are regions\n",effect_region_p(reg));
    if( ! region_to_minimal_dimensions(reg,tr,dimensions,offsets,true,condition) ) {
        pips_user_warning("failed to convert regions to minimal array dimensions, using whole array instead\n");
 
        bool success_p = false;
        // Try using a region based on the declaration (Old way)
        //success_p=declaration_region_to_dimensions(reg,tr,dimensions,offsets,condition);
 
        // Use directly the dimensions from the declaration without building a region!
        entity e = reference_variable(region_any_reference(reg));
        success_p=declarations_to_dimensions(e, dimensions, offsets);
 
        if(!success_p) {
          // Don't know how to recover from that...
          pips_internal_error("Abort");
        }
    }
}

References declarations_to_dimensions(), effect_region_p, pips_assert, pips_internal_error, pips_user_warning, reference_variable, region_any_reference, and region_to_minimal_dimensions().

Referenced by effects_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

region_to_minimal_dimensions()

bool region_to_minimal_dimensions	(	region	r,
		transformer	tr,
		list *	dims,
		list *	offsets,
		bool	exact,
		expression *	condition
	)

generate a list of dimensions dims and of offsets from a region r for example if r = a[phi0,phi1] 0<=phi0<=2 and 1<=phi1<=4 we get dims = ( (0,3), (0,4) ) and offsets = ( 0 , 1 ) if exact is set to false, we are allowed to give an upper bound to the dimensions

if at least one of the resulting dimension can be 0 (according to preconditions) dimension_may_be_null is set to true

Returns

false if we were enable to gather enough informations

this is a constant : the dimension is 1 and the offset is the bound

this is a range : the dimension is eupper-elower +1 and the offset is elower

sg : check if lower bound can be 0, in that case issue a ward

reset state

index is a field ...

and the last field, store it as an extra dimension

Definition at line 1207 of file isolate_statement.c.

{
    pips_assert("empty parameters\n",ENDP(*dims)&&ENDP(*offsets));
    reference ref = region_any_reference(r);
    bool fortran_p = fortran_module_p(get_current_module_entity());
    for(list iter = reference_indices(ref);!ENDP(iter); POP(iter))
    {
        expression index = EXPRESSION(CAR(iter));
        Variable phi = expression_to_entity(index);
        if(variable_phi_p((entity)phi)) {
            Psysteme sc = sc_dup(region_system(r));
            sc_transform_eg_in_ineg(sc);
            Pcontrainte lower,upper;
            constraints_for_bounds(phi, &sc_inegalites(sc), &lower, &upper);
            if( !CONTRAINTE_UNDEFINED_P(lower) && !CONTRAINTE_UNDEFINED_P(upper))
            {
                /* this is a constant : the dimension is 1 and the offset is the bound */
                if(bounds_equal_p(phi,lower,upper))
                {
#if 1
                    expression bound = constraints_to_loop_bound(lower,phi,true,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                    if (fortran_p) {
                        // in fortran remove -1 to the bound since index 1 is
                        // offset 0
                        bound = add_integer_to_expression (bound, -1);
                    }
                    *dims=CONS(DIMENSION,make_dimension(int_to_expression(0),int_to_expression(0),NIL),*dims);
                    *offsets=CONS(EXPRESSION,bound,*offsets);
#endif
                }
                /* this is a range : the dimension is eupper-elower +1 and the offset is elower */
                else
                {
 
                    expression elower = constraints_to_loop_bound(lower,phi,true,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                    expression eupper = constraints_to_loop_bound(upper,phi,false,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                    simplify_minmax_expression(elower,tr);
                    simplify_minmax_expression(eupper,tr);
                    expression offset = copy_expression(elower);
                    if (fortran_p) {
                        // in fortran remove -1 to the offset since index 1 is
                        // offset 0
                        offset = add_integer_to_expression (offset, -1);
                    }
 
                    bool compute_upperbound_p = 
                        !exact && (expression_minmax_p(elower)||expression_minmax_p(eupper));
                    expression dim = make_op_exp(MINUS_OPERATOR_NAME,eupper,elower);
                    if(compute_upperbound_p)
                        upperbound_of_expression(dim,tr);
 
                    /* sg : check if lower bound can be 0, in that case issue a ward */
                    if(condition!=0) {
                        expression lowerbound = copy_expression(dim);
                        lowerbound_of_expression(lowerbound,tr);
                        intptr_t lowerbound_value;
                        if(!expression_integer_value(lowerbound,&lowerbound_value) ||
                                lowerbound_value<=0) {
                            expression thetest = 
                                MakeBinaryCall(
                                        entity_intrinsic(GREATER_THAN_OPERATOR_NAME),
                                        copy_expression(dim),
                                        int_to_expression(0)
                                        );
                            if(expression_undefined_p(*condition))
                                *condition=thetest;
                            else
                                *condition=MakeBinaryCall(
                                        entity_intrinsic(AND_OPERATOR_NAME),
                                        *condition,
                                        thetest
                                        );
                        }
                    }
 
                    *dims=CONS(DIMENSION,
                               make_dimension(
                                              int_to_expression(0),
                                              dim,
                                              NIL),
                               *dims);
                    *offsets=CONS(EXPRESSION,offset,*offsets);
                }
            }
            else {
                pips_user_warning("failed to analyse region\n");
                sc_free(sc);
                /* reset state */
                gen_full_free_list(*dims); *dims=NIL;
                gen_full_free_list(*offsets); *offsets=NIL;
                return false;
            }
            sc_free(sc);
        }
        /* index is a field ... */
        else { /* and the last field, store it as an extra dimension */
#if 0
            *dims=CONS(DIMENSION,
                    make_dimension(
                                   int_to_expression(0),
                                   int_to_expression(0),
                                   NIL
                        ),*dims);
            *offsets=CONS(EXPRESSION,copy_expression(index),*offsets);
#else
            break;
#endif
        }
    }
    *dims=gen_nreverse(*dims);
    *offsets=gen_nreverse(*offsets);
    return true;
}

References add_integer_to_expression(), AND_OPERATOR_NAME, bounds_equal_p(), CAR, CONS, constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED_P, copy_expression(), DIMENSION, DIVIDE_OPERATOR_NAME, ENDP, entity_intrinsic(), EXPRESSION, expression_integer_value(), expression_minmax_p(), expression_to_entity(), expression_undefined_p, fortran_module_p(), gen_full_free_list(), gen_nreverse(), get_current_module_entity(), GREATER_THAN_OPERATOR_NAME, int_to_expression(), intptr_t, lowerbound_of_expression(), make_dimension(), make_op_exp(), MakeBinaryCall(), MINUS_OPERATOR_NAME, NIL, offset, pips_assert, pips_user_warning, POP, ref, reference_indices, region_any_reference, region_system, sc_dup(), sc_free(), sc_transform_eg_in_ineg(), simplify_minmax_expression(), upperbound_of_expression(), and variable_phi_p.

Referenced by region_to_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

upperbound_of_expression()

static void upperbound_of_expression ( expression  e, transformer  tr  )

static

replaces expression e by its upperbound under preconditions tr

Definition at line 1182 of file isolate_statement.c.

{
    bounds_of_expression(e,tr,true);
}

References bounds_of_expression().

Referenced by region_to_minimal_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_to_dimensions()

list variable_to_dimensions

(

region

reg_from

)

We may skip the size of the first dimension since it is not used in address calculation. But since it depends of Fortran or C in the runtime, postpone this micro-optimization...

we are in trouble, as we don't know anything about the size of the underlying array. It is the fist dimension, so not very important anyway ... except for FORTRAN :-( But there are no pointer in FORTRAN :p

Definition at line 319 of file isolate_statement.c.

                                             {
    /* We may skip the size of the first dimension since it is not
       used in address calculation. But since it depends of Fortran
       or C in the runtime, postpone this micro-optimization... */
    reference r =region_any_reference(reg_from);
    entity from = reference_variable(r);
    variable from_tv = type_variable(ultimate_type(entity_type(from)));
    list dims = variable_dimensions(from_tv);
    list out=NIL;
    FOREACH(EXPRESSION,exp, reference_indices(r)) {
        pips_assert("a region only contains references", expression_reference_p(exp));
        reference rexp = expression_reference(exp);
        entity var = reference_variable(rexp);
        if(variable_phi_p(var)) {
            /* we are in trouble, as we don't know anything about the size of the underlying array. It is the fist dimension, so not very important anyway ... except for FORTRAN :-( But there are no pointer in FORTRAN :p */
            if(ENDP(dims) && basic_pointer_p(variable_basic(from_tv))) {
                pips_assert("no pointer in fortran", c_module_p(get_current_module_entity()));
                expression eupper = expression_undefined;
                Psysteme sc_reg = sc_dup(region_system(reg_from));
                sc_transform_eg_in_ineg(sc_reg);
                Pcontrainte lower,upper;
                constraints_for_bounds(var,
                        &sc_inegalites(sc_reg), &lower, &upper);
                if( !CONTRAINTE_UNDEFINED_P(upper))
                {
                    eupper = constraints_to_loop_bound(upper,var,false,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                }
                else {
                    pips_internal_error("Should not happen at this point, should it ?");
                }
 
                out=CONS(DIMENSION,
                         make_dimension(int_to_expression(0), eupper, NIL),
                         out);
                from_tv = type_variable(ultimate_type(basic_pointer(variable_basic(from_tv))));
                dims = variable_dimensions(from_tv);
            }
            else {
                pips_assert("some dims stacked", !ENDP(dims));
                out=CONS(DIMENSION, copy_dimension(DIMENSION(CAR(dims))), out);
                POP(dims);
            }
        }
        else if(entity_field_p(var)) {
            break;
        }
    }
    return gen_nreverse(out);
}

References basic_pointer, basic_pointer_p, c_module_p(), CAR, CONS, constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED_P, copy_dimension(), DIMENSION, DIVIDE_OPERATOR_NAME, ENDP, entity_field_p(), entity_intrinsic(), entity_type, exp, EXPRESSION, expression_reference(), expression_reference_p(), expression_undefined, FOREACH, gen_nreverse(), get_current_module_entity(), int_to_expression(), make_dimension(), NIL, out, pips_assert, pips_internal_error, POP, reference_indices, reference_variable, region_any_reference, region_system, sc_dup(), sc_transform_eg_in_ineg(), type_variable, ultimate_type(), variable_basic, variable_dimensions, and variable_phi_p.

Referenced by dimensions_to_dma().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

dma1D

const int dma1D = 1

static

Some constant intended to have a more readable code.

Definition at line 77 of file isolate_statement.c.

Referenced by effects_to_dma().