reductions.c File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "resources.h"
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "effects-generic.h"
#include "accel-util.h"
#include "reductions.h"
#include "sac.h"
#include "ricedg.h"
#include "effects-convex.h"
#include "effects-simple.h"
#include "control.h"
#include "callgraph.h"
#include "properties.h"

Include dependency graph for reductions.c:

Go to the source code of this file.

Data Structures
struct	reduction_in_statement_param
	finds out expression with reduction More...

Functions
bool	sac_expression_reduction_p (expression e)
	reductions.c More...
static entity	make_reduction_vector_entity (reduction r)
static reductionInfo	add_reduction (list *reds, reduction r)
	The first part of the function check that the reduction is allowed. More...
static void	undo_rename_reference (reference r, reductionInfo ri)
static void	rename_reduction_ref_walker (expression e, reductionInfo ri)
static bool	reduction_in_statement_walker (reference r, reduction_in_statement_param *p)
static bool	reduction_in_statement_p (reduction red, statement stat)
static void	rename_statement_reductions (statement s, list *reductions_info, list reductions)
	This function gets the possible reduction thanks to load_cumulated_reductions() function. More...
static expression	make_maxval_expression (basic b)
static expression	make_minval_expression (basic b)
static expression	make_0val_expression (basic b)
static expression	make_1val_expression (basic b)
static statement	generate_prelude (reductionInfo ri)
static statement	generate_compact (reductionInfo ri)
static bool	simd_gather_reduction (statement body, list reductions, list *reductions_info)
static void	reductions_rewrite (statement s, set skip)
static bool	reduction_rewrite_filter (statement s, set skip)
bool	simd_remove_reductions (char *mod_name)
	remove reductions by expanding reduced scalar to an array More...
static bool	no_write_read_conflicts_p (list succs)
static bool	potential_out_effects_p (statement s)
static void	do_redundant_load_store_elimination (graph dg)
bool	redundant_load_store_elimination (char *module_name)

Function Documentation

add_reduction()

static reductionInfo add_reduction ( list *  reds, reduction  r  )

static

The first part of the function check that the reduction is allowed.

If not, the function returns undefined. If the reduction is allowed, the function updates the reductionInfo list reds or add the reduction to the list.

Definition at line 85 of file reductions.c.

{
    reductionInfo ri = reductionInfo_undefined;
 
    pips_debug(1, "reduction reference %s\n", entity_local_name(reference_variable(reduction_reference(r))));
 
    //See if the reduction has already been encountered
    FOREACH(REDUCTIONINFO,ri,*reds)
    {
        if (same_reduction_p(r, reductionInfo_reduction(ri)))
        {
            //The reduction has already been encountered: update the counter
            reductionInfo_count(ri)++;
 
            free_expression(dimension_upper(DIMENSION(CAR((variable_dimensions(type_variable(entity_type(reductionInfo_vector(ri)))))))));
            dimension_upper(DIMENSION(CAR((variable_dimensions(type_variable(entity_type(reductionInfo_vector(ri)))))))) = int_to_expression(reductionInfo_count(ri)-1);
 
            return ri; 
        }
    }
 
    //First time we see this reduction: initialize a reductionInfo structure
    ri = make_reductionInfo(r, 1, make_reduction_vector_entity(r));
 
    //Add to the list of reductions encountered
    *reds=CONS(REDUCTIONINFO,ri,*reds);
 
    return ri;
}

References CAR, CONS, DIMENSION, dimension_upper, entity_local_name(), entity_type, FOREACH, free_expression(), int_to_expression(), make_reduction_vector_entity(), make_reductionInfo(), pips_debug, reduction_reference, REDUCTIONINFO, reductionInfo_count, reductionInfo_reduction, reductionInfo_undefined, reductionInfo_vector, reference_variable, same_reduction_p(), type_variable, and variable_dimensions.

Referenced by rename_statement_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

do_redundant_load_store_elimination()

static void do_redundant_load_store_elimination ( graph  dg )

static

Definition at line 752 of file reductions.c.

                                                          {
    bool did_something ;
    set deleted_vertex = set_make(set_pointer);
    do {
        did_something=false;
        statement deleted = statement_undefined;
        FOREACH(VERTEX,v,graph_vertices(dg) ) {
            if(!set_belong_p(deleted_vertex,v) && no_write_read_conflicts_p(vertex_successors(v))) {
                statement s = vertex_to_statement(v);
                if(statement_call_p(s) && 
                        !return_statement_p(s) &&
                        !declaration_statement_p(s) &&
                        !potential_out_effects_p(s) ) {
                    update_statement_instruction(s,make_continue_instruction());
                    did_something=true;
                    deleted=s;
                    set_add_element(deleted_vertex,deleted_vertex,v);
                    break;
                }
            }
        }
 
        if(!statement_undefined_p(deleted)) {
            FOREACH(VERTEX,v,graph_vertices(dg) ) {
                if(!set_belong_p(deleted_vertex,v)) {
                    list tmp = gen_copy_seq(vertex_successors(v));
                    FOREACH(SUCCESSOR,s,tmp) {
                        if(vertex_to_statement(successor_vertex(s)) == deleted )
                            gen_remove(&vertex_successors(v),s);
                    }
                }
            }
        }
    } while(did_something);
}

References declaration_statement_p(), dg, FOREACH, gen_copy_seq(), gen_remove(), graph_vertices, make_continue_instruction(), no_write_read_conflicts_p(), potential_out_effects_p(), return_statement_p(), set_add_element(), set_belong_p(), set_make(), set_pointer, statement_call_p(), statement_undefined, statement_undefined_p, SUCCESSOR, successor_vertex, update_statement_instruction(), VERTEX, vertex_successors, and vertex_to_statement().

Referenced by redundant_load_store_elimination().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_compact()

static statement generate_compact ( reductionInfo  ri )

static

Definition at line 355 of file reductions.c.

{
    expression rightExpr;
    entity operator;
    instruction compact;
    int i;
 
    // According to the operator, get the correct entity
    switch(reduction_operator_tag(reduction_op(reductionInfo_reduction(ri))))
    {
        default:
        case is_reduction_operator_none:
            return statement_undefined;  //nothing to generate
            break;
 
        case is_reduction_operator_min:
            operator = entity_intrinsic(MIN_OPERATOR_NAME);
            break;
 
        case is_reduction_operator_max:
            operator = entity_intrinsic(MAX_OPERATOR_NAME);
            break;
 
        case is_reduction_operator_sum:
                operator = entity_intrinsic(PLUS_OPERATOR_NAME);
            break;
 
        case is_reduction_operator_csum:
            operator = entity_intrinsic(PLUS_C_OPERATOR_NAME);
            break;
 
        case is_reduction_operator_prod:
            operator = entity_intrinsic(MULTIPLY_OPERATOR_NAME);
            break;
 
        case is_reduction_operator_and:
            operator = entity_intrinsic(AND_OPERATOR_NAME);
            break;
 
        case is_reduction_operator_or:
            operator = entity_intrinsic(OR_OPERATOR_NAME);
            break;
    }
 
    // Get the reduction variable
    rightExpr = reference_to_expression(copy_reference(reduction_reference(reductionInfo_reduction(ri))));
 
    const char* spostlude = get_string_property("SIMD_REMOVE_REDUCTIONS_POSTLUDE");
    statement postlude = statement_undefined;
    if(empty_string_p(spostlude) || !(reduction_operator_sum_p(reduction_op(reductionInfo_reduction(ri))))) {
        // For each reductionInfo_vector reference, add it to the compact statement
        for(i=0; i<reductionInfo_count(ri); i++)
        {
            call c;
            expression e;
 
            e = reference_to_expression(make_reference(
                        reductionInfo_vector(ri), CONS(EXPRESSION, int_to_expression(i), NIL)));
            c = make_call(operator, CONS(EXPRESSION, e, 
                        CONS(EXPRESSION, rightExpr, NIL)));
 
            rightExpr = call_to_expression(c);
        }
 
        // Make the compact assignment statement
        compact = make_assign_instruction(
                reference_to_expression(copy_reference(reduction_reference(reductionInfo_reduction(ri)))),
                rightExpr);
 
        postlude= instruction_to_statement(compact);
    }
    else {
        entity epostlude = FindEntity(TOP_LEVEL_MODULE_NAME,spostlude);
        if(entity_undefined_p(epostlude)) {
            pips_user_warning("%s not found, using a dummy one",spostlude);
            epostlude=make_empty_subroutine(spostlude,copy_language(module_language(get_current_module_entity())));
        }
        postlude=call_to_statement(
                make_call(
                    epostlude,
                    make_expression_list(
                        MakeUnaryCall(
                            entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),
                            reference_to_expression(copy_reference(reduction_reference(reductionInfo_reduction(ri))))
                            ),
                        MakeUnaryCall(
                            entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),
                            reference_to_expression(
                                make_reference(
                                    reductionInfo_vector(ri),
                                    CONS(EXPRESSION,int_to_expression(0),NIL)
                                    )
                                )
                            )
                        )
                    )
                );
    }
    return postlude;
}

References ADDRESS_OF_OPERATOR_NAME, AND_OPERATOR_NAME, call_to_expression(), call_to_statement, CONS, copy_language(), copy_reference(), empty_string_p(), entity_intrinsic(), entity_undefined_p, EXPRESSION, FindEntity(), get_current_module_entity(), get_string_property(), instruction_to_statement(), int_to_expression(), is_reduction_operator_and, is_reduction_operator_csum, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_none, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, make_assign_instruction(), make_call(), make_empty_subroutine(), make_expression_list, make_reference(), MakeUnaryCall(), MAX_OPERATOR_NAME, MIN_OPERATOR_NAME, module_language, MULTIPLY_OPERATOR_NAME, NIL, OR_OPERATOR_NAME, pips_user_warning, PLUS_C_OPERATOR_NAME, PLUS_OPERATOR_NAME, reduction_op, reduction_operator_sum_p, reduction_operator_tag, reduction_reference, reductionInfo_count, reductionInfo_reduction, reductionInfo_vector, reference_to_expression(), statement_undefined, and TOP_LEVEL_MODULE_NAME.

Referenced by reductions_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_prelude()

static statement generate_prelude ( reductionInfo  ri )

static

Definition at line 287 of file reductions.c.

{
    expression initval;
    list prelude = NIL;
    int i;
    basic bas = basic_of_reference(reduction_reference(reductionInfo_reduction(ri)));
 
    // According to the operator, get the correct initialization value
    // should use operator_neutral_element
    switch(reduction_operator_tag(reduction_op(reductionInfo_reduction(ri))))
    {
        default:
        case is_reduction_operator_none:
            return statement_undefined;
            break;
 
        case is_reduction_operator_min:
            initval = make_maxval_expression(bas);
            break;
 
        case is_reduction_operator_max:
            initval = make_minval_expression(bas);
            break;
 
        case is_reduction_operator_sum:
            initval = make_0val_expression(bas);
            break;
 
        case is_reduction_operator_prod:
            initval = make_1val_expression(bas);
            break;
 
        case is_reduction_operator_and:
            initval = bool_to_expression(true);
            break;
 
        case is_reduction_operator_or:
            initval = bool_to_expression(false);
            break;
    }
 
    // For each reductionInfo_vector reference, make an initialization
    // assign statement and add it to the prelude
    // do nothing if no init val exist
    for(i=0; i<reductionInfo_count(ri); i++)
    {
        instruction is;
    
        is = make_assign_instruction(
            reference_to_expression(make_reference(
                    reductionInfo_vector(ri), CONS(EXPRESSION, 
                        int_to_expression(reductionInfo_count(ri)-i-1),
                        NIL))),
            copy_expression(initval));
    
        prelude = CONS(STATEMENT, 
            instruction_to_statement(is),
            prelude);
    }
 
    free_expression(initval);
 
    return instruction_to_statement(make_instruction_sequence(make_sequence(prelude)));
}

References basic_of_reference(), bool_to_expression(), CONS, copy_expression(), EXPRESSION, free_expression(), instruction_to_statement(), int_to_expression(), is_reduction_operator_and, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_none, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, make_0val_expression(), make_1val_expression(), make_assign_instruction(), make_instruction_sequence(), make_maxval_expression(), make_minval_expression(), make_reference(), make_sequence(), NIL, reduction_op, reduction_operator_tag, reduction_reference, reductionInfo_count, reductionInfo_reduction, reductionInfo_vector, reference_to_expression(), STATEMENT, and statement_undefined.

Referenced by reductions_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

make_0val_expression()

static expression make_0val_expression ( basic  b )

static

Definition at line 243 of file reductions.c.

{
    switch(basic_tag(b))
    {
        case is_basic_float:
            return float_to_expression(0);
 
        case is_basic_int:
            return int_to_expression(0);
 
        case is_basic_complex:
            return complex_to_expression(0,0);
 
        default:
            pips_internal_error("function not implemented for this basic ");
    }
    return expression_undefined;
}

References basic_tag, complex_to_expression(), expression_undefined, float_to_expression(), int_to_expression(), is_basic_complex, is_basic_float, is_basic_int, and pips_internal_error.

Referenced by generate_prelude().

Here is the call graph for this function:

Here is the caller graph for this function:

make_1val_expression()

static expression make_1val_expression ( basic  b )

static

Definition at line 266 of file reductions.c.

{
    switch(basic_tag(b))
    {
        case is_basic_float:
            return float_to_expression(1);
 
        case is_basic_int:
            return int_to_expression(1);
 
        case is_basic_complex:
            return complex_to_expression(0,1);
 
        default:
            return expression_undefined;
    }
}

References basic_tag, complex_to_expression(), expression_undefined, float_to_expression(), int_to_expression(), is_basic_complex, is_basic_float, and is_basic_int.

Referenced by generate_prelude().

Here is the call graph for this function:

Here is the caller graph for this function:

make_maxval_expression()

static expression make_maxval_expression ( basic  b )

static

Definition at line 199 of file reductions.c.

{
    switch(basic_tag(b))
    {
        case is_basic_float:
            return expression_undefined;
 
        case is_basic_int:
            {
                long long max = (2 << (basic_int(b) - 2)) - 1;
                return int_to_expression(max);
            }
 
        default:
            return expression_undefined;
    }
}

References basic_int, basic_tag, expression_undefined, int_to_expression(), is_basic_float, is_basic_int, and max.

Referenced by generate_prelude().

Here is the call graph for this function:

Here is the caller graph for this function:

make_minval_expression()

static expression make_minval_expression ( basic  b )

static

Definition at line 221 of file reductions.c.

{
    switch(basic_tag(b))
    {
        case is_basic_float:
            return expression_undefined;
 
        case is_basic_int:
            {
                long long min = -(2 << (basic_int(b) - 2));
                return int_to_expression(min);
            }
 
        default:
            return expression_undefined;
    }
}

References basic_int, basic_tag, expression_undefined, int_to_expression(), is_basic_float, is_basic_int, and min.

Referenced by generate_prelude().

Here is the call graph for this function:

Here is the caller graph for this function:

make_reduction_vector_entity()

static entity make_reduction_vector_entity ( reduction  r )

static

Definition at line 64 of file reductions.c.

{
    basic base = basic_of_reference(reduction_reference(r));
    entity new_ent, mod_ent;
    static int counter = 0;
    const char *prefix = get_string_property("SIMD_REMOVE_REDUCTIONS_PREFIX") ;
    char buffer[ 1 + 3 + strlen(prefix) ];
    pips_assert("buffer does not overflow",counter < 1000);
    sprintf(buffer,"%s%u",prefix,counter++);
 
    mod_ent = get_current_module_entity();
    list lis = CONS(DIMENSION,make_dimension(int_to_expression(0),int_to_expression(0),NIL), NIL);
    new_ent = make_new_array_variable_with_prefix(buffer,mod_ent,base,lis);
    AddLocalEntityToDeclarations(new_ent,mod_ent,get_current_module_statement());
    return new_ent;
}

References AddLocalEntityToDeclarations(), base, basic_of_reference(), buffer, CONS, DIMENSION, get_current_module_entity(), get_current_module_statement(), get_string_property(), int_to_expression(), make_dimension(), make_new_array_variable_with_prefix(), mod_ent, NIL, pips_assert, prefix, and reduction_reference.

Referenced by add_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

no_write_read_conflicts_p()

static bool no_write_read_conflicts_p ( list  succs )

static

Definition at line 716 of file reductions.c.

                                                  {
        FOREACH(SUCCESSOR, succ, succs) {
                FOREACH(CONFLICT, c, dg_arc_label_conflicts(successor_arc_label(succ))) {
                        if (effect_write_p(conflict_source(c)) &&
                            effect_read_p(conflict_sink(c)))
                                return false;
                }
        }
        return true;
}

References CONFLICT, conflict_sink, conflict_source, dg_arc_label_conflicts, effect_read_p, effect_write_p, FOREACH, SUCCESSOR, and successor_arc_label.

Referenced by do_redundant_load_store_elimination().

Here is the caller graph for this function:

potential_out_effects_p()

static bool potential_out_effects_p ( statement  s )

static

get_current_module_statement()

Definition at line 727 of file reductions.c.

                                                 {
    FOREACH(EFFECT,eff,load_proper_rw_effects_list(s)) if(io_effect_p(eff)) return true;
    if(get_bool_property("REDUNDANT_LOAD_STORE_ELIMINATION_CONSERVATIVE")) {
        list write_effects = effects_write_effects(load_proper_rw_effects_list(s));
        bool out_effect = false;
        FOREACH(EFFECT,eff,write_effects) {
            reference r = effect_any_reference(eff);
            if( anywhere_effect_p(eff) ||
                    ( formal_parameter_p(reference_variable(r)) && !ENDP(reference_indices(r)) ) ||
                    top_level_entity_p(reference_variable(r))
              ) {
                out_effect=true;break;
            }
        }
        gen_free_list(write_effects);
        return out_effect;
    }
    else {
 
        list out_effects = load_cumulated_rw_effects_list(s /* get_current_module_statement() */);
        return !ENDP(out_effects);
    }
 
}

References anywhere_effect_p(), EFFECT, effect_any_reference, effects_write_effects(), ENDP, FOREACH, formal_parameter_p(), gen_free_list(), get_bool_property(), io_effect_p(), load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), out_effects(), reference_indices, reference_variable, top_level_entity_p(), and write_effects().

Referenced by do_redundant_load_store_elimination().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_in_statement_p()

static bool reduction_in_statement_p ( reduction  red, statement  stat  )

static

Definition at line 151 of file reductions.c.

{
    reduction_in_statement_param p ={ red, false };
    gen_context_recurse(stat, &p, reference_domain, reduction_in_statement_walker, gen_null2);
    return p.has_reduction_p;
}

References gen_context_recurse, gen_null2(), reduction_in_statement_param::has_reduction_p, reduction_in_statement_walker(), and reference_domain.

Referenced by rename_statement_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_in_statement_walker()

static bool reduction_in_statement_walker ( reference  r, reduction_in_statement_param *  p  )

static

Definition at line 145 of file reductions.c.

{
    p->has_reduction_p|=reference_equal_p(r, reduction_reference(p->red));
    return ! p->has_reduction_p;
}

References reduction_in_statement_param::has_reduction_p, reduction_in_statement_param::red, reduction_reference, and reference_equal_p().

Referenced by reduction_in_statement_p().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_rewrite_filter()

static bool reduction_rewrite_filter ( statement  s, set  skip  )

static

Definition at line 557 of file reductions.c.

{
        if (statement_loop_p(s))
        set_add_element(skip,skip,loop_body(statement_loop(s)));
        return true;
}

References loop_body, set_add_element(), statement_loop(), and statement_loop_p().

Referenced by simd_remove_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

reductions_rewrite()

static void reductions_rewrite ( statement  s, set  skip  )

static

we may have failed to find any reduction info, in that case try again with the inner reductions

not enough elements: undo the change

Definition at line 475 of file reductions.c.

{
    if(set_belong_p(skip,s)) return;
    instruction i = statement_instruction(s);
    statement body;
    bool is_loop=true;
 
    //We are only interested in loops
    switch(instruction_tag(i))
    {
        case is_instruction_loop:
            body = loop_body(instruction_loop(i));
            break;
 
        case is_instruction_whileloop:
            body = whileloop_body(instruction_whileloop(i));
            break;
 
        case is_instruction_forloop:
            body = forloop_body(instruction_forloop(i));
            break;
 
        case is_instruction_sequence:
            body = s;
            is_loop=false;
            break;
 
        default:
            return;
    }
    {
 
        list reductions_info = NIL;
        list preludes = NIL;
        list compacts = NIL;
 
        //Compute the reductions list for the loop
        list reductions = reductions_list(load_cumulated_reductions(s));
        ifdebug(2) {
            if(!ENDP(reductions))
                pips_debug(2,"found reductions for loop:\n");
            else
                pips_debug(2,"no reduction for loop:\n");
            print_statement(s);
        }
        //Lookup the reductions in the loop's body, and change the loop body accordingly
        if(!simd_gather_reduction(body,reductions,&reductions_info)) {
            /* we may have failed to find any reduction info, in that case try again with the inner reductions */
            reductions =  reductions_list(load_cumulated_reductions(body));
            simd_gather_reduction(body,reductions,&reductions_info);
            s=body;
        }
 
 
        //Generate prelude and compact code for each of the reductions
        FOREACH(REDUCTIONINFO, ri,reductions_info)
        {
            if(entity_memory_size(reductionInfo_vector(ri))*8 >= get_int_property("SAC_SIMD_REGISTER_WIDTH")) {
            statement curStat = generate_prelude(ri);
            if (curStat != statement_undefined)
                preludes = CONS(STATEMENT, curStat, preludes);
 
            curStat = generate_compact(ri);
            if (curStat != statement_undefined)
                compacts = CONS(STATEMENT, curStat, compacts);
            }
            /* not enough elements: undo the change */
            else {
                gen_context_recurse(body, ri, reference_domain, gen_true2, undo_rename_reference);
            }
        };
        gen_full_free_list(reductions_info);
 
        // Replace the old statement instruction by the new one
    gen_recurse_stop(compacts);
        insert_statement(s,make_block_statement(compacts),false);
        insert_statement(s,make_block_statement(preludes),true);
 
    }
    if(is_loop) gen_recurse_stop(statement_instruction(s));
}

References CONS, ENDP, entity_memory_size(), FOREACH, forloop_body, gen_context_recurse, gen_full_free_list(), gen_recurse_stop(), gen_true2(), generate_compact(), generate_prelude(), get_int_property(), ifdebug, insert_statement(), instruction_forloop, instruction_loop, instruction_tag, instruction_whileloop, is_instruction_forloop, is_instruction_loop, is_instruction_sequence, is_instruction_whileloop, load_cumulated_reductions(), loop_body, make_block_statement(), NIL, pips_debug, print_statement(), REDUCTIONINFO, reductionInfo_vector, reductions_list, reference_domain, set_belong_p(), simd_gather_reduction(), STATEMENT, statement_instruction, statement_undefined, undo_rename_reference(), and whileloop_body.

Referenced by simd_remove_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

redundant_load_store_elimination()

bool redundant_load_store_elimination

(

char *

module_name

)

Get the code of the module.

Parameters

module_name

odule_name

Definition at line 788 of file reductions.c.

{
    /* Get the code of the module. */
    entity module = module_name_to_entity(module_name);
    statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
        set_ordering_to_statement(module_stat);
    set_current_module_entity( module);
    set_current_module_statement( module_stat);
    set_proper_rw_effects((statement_effects) db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
 
    graph dependence_graph = (graph) db_get_memory_resource(DBR_CHAINS, module_name, true);
 
    // buggy and incomplete
    //do_sac_reduction_optimizations(dependence_graph);
    do_redundant_load_store_elimination(dependence_graph);
 
    unnormalize_expression(module_stat);
    module_reorder(module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
 
    reset_current_module_entity();
        reset_ordering_to_statement();
    reset_current_module_statement();
    reset_proper_rw_effects();
    reset_cumulated_rw_effects();
 
    return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, dependence_graph, do_redundant_load_store_elimination(), get_current_module_statement(), module, module_name(), module_name_to_entity(), module_reorder(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), and unnormalize_expression().

Here is the call graph for this function:

rename_reduction_ref_walker()

static void rename_reduction_ref_walker ( expression  e, reductionInfo  ri  )

static

Definition at line 126 of file reductions.c.

{
    syntax s = expression_syntax(e);
 
    if (syntax_reference_p(s) &&
            reference_equal_p(syntax_reference(s), reduction_reference(reductionInfo_reduction(ri))))
    {
        free_reference(syntax_reference(s));
        syntax_reference(s)= make_reference(reductionInfo_vector(ri),
                make_expression_list(int_to_expression(reductionInfo_count(ri)-1)));
    }
}

References expression_syntax, free_reference(), int_to_expression(), make_expression_list, make_reference(), reduction_reference, reductionInfo_count, reductionInfo_reduction, reductionInfo_vector, reference_equal_p(), syntax_reference, and syntax_reference_p.

Referenced by rename_statement_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

rename_statement_reductions()

static void rename_statement_reductions ( statement  s, list *  reductions_info, list  reductions  )

static

This function gets the possible reduction thanks to load_cumulated_reductions() function.

Then, for each possible reduction, the function call add_reduction() to know if the reduction is allowed and if it is, the function calls rename_reduction_ref() to do the reduction.

Definition at line 163 of file reductions.c.

{
    ifdebug(3) {
        pips_debug(3,"considering statement:\n");
        print_statement(s);
    }
    FOREACH(REDUCTION, r, reductions)
    {
        ifdebug(3) {
            pips_debug(3,"considering reduction:\n");
            print_reference(reduction_reference(r));
            fprintf(stderr,"\n");
        }
        if(reduction_star_p(r))
            pips_debug(3,"can do nothing with star reductions ...\n");
        else if(reduction_in_statement_p(r,s))
        {
            pips_debug(3,"found in the statement ! Rewriting ...\n");
            basic b = basic_of_reference(reduction_reference(r));
            if(!basic_undefined_p(b))
            {
                free_basic(b);
                reductionInfo ri = add_reduction(reductions_info, r);
                if( ! reductionInfo_undefined_p(ri))
                    gen_context_recurse(s,ri,expression_domain,gen_true2,rename_reduction_ref_walker);
            }
        }
        else
            pips_debug(3,"not found in the statement ! Skipping ...\n");
    }
}

References add_reduction(), basic_of_reference(), basic_undefined_p, expression_domain, FOREACH, fprintf(), free_basic(), gen_context_recurse, gen_true2(), ifdebug, pips_debug, print_reference(), print_statement(), REDUCTION, reduction_in_statement_p(), reduction_reference, reduction_star_p(), reductionInfo_undefined_p, and rename_reduction_ref_walker().

Referenced by simd_gather_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

sac_expression_reduction_p()

bool sac_expression_reduction_p

(

expression

e

)

reductions.c

Definition at line 55 of file reductions.c.

                                             {
    if(expression_reference_p(e)) {
        const char* refname = entity_user_name(reference_variable(expression_reference(e)));
        if(refname==strstr(refname,get_string_property("SIMD_REMOVE_REDUCTIONS_PREFIX")))
            return true;
    }
    return false;
}

References entity_user_name(), expression_reference(), expression_reference_p(), get_string_property(), and reference_variable.

Here is the call graph for this function:

simd_gather_reduction()

static bool simd_gather_reduction ( statement  body, list  reductions, list *  reductions_info  )

static

Definition at line 456 of file reductions.c.

                                                                                   {
        instruction ibody = statement_instruction(body);
        switch(instruction_tag(ibody))
        {
            case is_instruction_sequence:
                {
                    FOREACH(STATEMENT, curStat,sequence_statements(instruction_sequence(ibody)))
                        rename_statement_reductions(curStat, reductions_info, reductions);
                } break;
 
            default:
                return false;
        }
        return !ENDP(*reductions_info);
}

References ENDP, FOREACH, instruction_sequence, instruction_tag, is_instruction_sequence, rename_statement_reductions(), sequence_statements, STATEMENT, and statement_instruction.

Referenced by reductions_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_remove_reductions()

bool simd_remove_reductions

(

char *

mod_name

)

remove reductions by expanding reduced scalar to an array

Parameters

mod_name

module to remove reductions from

Returns

true

get the resources

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

mod_name

od_name

Definition at line 571 of file reductions.c.

{
 
    /* get the resources */
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE, mod_name,true));
    set_current_module_entity(module_name_to_entity(mod_name));
    set_cumulated_reductions((pstatement_reductions) db_get_memory_resource(DBR_CUMULATED_REDUCTIONS, mod_name, true));
 
    debug_on("SIMDREDUCTION_DEBUG_LEVEL");
 
    /* Now do the job */
    set skip = set_make(set_pointer);
    gen_context_recurse(get_current_module_statement(),skip, statement_domain, reduction_rewrite_filter, reductions_rewrite);
    set_free(skip);
 
    pips_assert("Statement is consistent after remove reductions", statement_consistent_p(get_current_module_statement()));
 
    /* Reorder the module, because new statements have been added */  
    clean_up_sequences(get_current_module_statement());
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, mod_name, compute_callees(get_current_module_statement()));
 
    /* update/release resources */
    reset_cumulated_reductions();
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_context_recurse, get_current_module_statement(), module_name_to_entity(), module_reorder(), pips_assert, reduction_rewrite_filter(), reductions_rewrite(), reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_reductions(), set_current_module_entity(), set_current_module_statement(), set_free(), set_make(), set_pointer, statement_consistent_p(), and statement_domain.

Here is the call graph for this function:

undo_rename_reference()

static void undo_rename_reference ( reference  r, reductionInfo  ri  )

static

Definition at line 115 of file reductions.c.

                                                                 {
    if(same_entity_p(
                reference_variable(r),
                reductionInfo_vector(ri))) {
        reference rred = reduction_reference(reductionInfo_reduction(ri));
        gen_full_free_list(reference_indices(r));
        reference_indices(r)=gen_full_copy_list(reference_indices(rred));
        reference_variable(r)=reference_variable(rred);
    }
}

References gen_full_copy_list(), gen_full_free_list(), reduction_reference, reductionInfo_reduction, reductionInfo_vector, reference_indices, reference_variable, and same_entity_p().

Referenced by reductions_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function: