atomizer.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "effects-util.h"
#include "text-util.h"
#include "database.h"
#include "misc.h"
#include "pipsdbm.h"
#include "resources.h"
#include "control.h"
#include "arithmetique.h"
#include "reductions.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "properties.h"
#include "sac.h"

Include dependency graph for atomizer.c:

Go to the source code of this file.

Functions
static void	patch_constant_size (syntax s, bool *patch_all)
statement	simd_atomize_this_expression (entity(*create)(entity, basic), expression e)
	returns the assignment statement if moved, or NULL if not. More...
static void	get_type_max_width (call ca, int *maxWidth)
	This function computes the maximum width of all the variables used in a call. More...
static void	change_basic_if_needed (statement stat)
	This function aims at changing the basic size of the left expression of the newly created assign statement. More...
static void	simd_insert_statement (statement cs, statement stat)
	This function insert stat before orginal_statement in the code. More...
static entity	sac_make_new_variable (entity module, basic b)
static void	simd_do_atomize (expression ce, statement cs)
static bool	reference_filter (expression exp, __attribute__((unused)) statement cs)
static void	atomize_call_statement (statement cs)
	This function is called for each call statement and atomize it. More...
static void	atomize_statements (statement cs)
	This function is called for all statements in the code. More...
bool	simd_atomizer (char *mod_name)
static bool	do_expression_reduction (statement s, reduction r, expression e)
static bool	do_reduction_atomization (statement s)
bool	reduction_atomization (const char *module_name)

Variables
static statement	orginal_statement = NULL
	An atomizer that uses the one made by Fabien Coelho for HPFC, and is in fact just a hacked version of the one made by Ronan Keryell... More...
static expression	current_lhs = expression_undefined

Function Documentation

atomize_call_statement()

static void atomize_call_statement ( statement  cs )

static

This function is called for each call statement and atomize it.

Definition at line 322 of file atomizer.c.

{
    call c = instruction_call(statement_instruction(cs));
 
    // Initialize orginal_statement if this is the first argument
    orginal_statement=cs;
 
    // For each call argument, the argument is atomized if needed
        if( ENTITY_ASSIGN_P(call_function(c)) )
        {
        current_lhs = binary_call_lhs(c);
                expression rhs = binary_call_rhs(c);
                if( expression_call_p(rhs) )
                {
                        FOREACH(EXPRESSION, arg,call_arguments(expression_call(rhs)))
                                gen_context_recurse(arg,cs,expression_domain,reference_filter,simd_do_atomize);
                }
        else if (expression_reference_p(rhs)) {
                                gen_context_recurse(rhs,cs,expression_domain,reference_filter,simd_do_atomize);
        }
        if(get_bool_property("SIMD_ATOMIZER_ATOMIZE_LHS"))
        {
            expression lhs = EXPRESSION(CAR(call_arguments(c)));
            gen_context_recurse(lhs,cs,expression_domain,reference_filter,simd_do_atomize);
        }
        }
}

References binary_call_lhs, binary_call_rhs, call_arguments, call_function, CAR, current_lhs, ENTITY_ASSIGN_P, EXPRESSION, expression_call(), expression_call_p(), expression_domain, expression_reference_p(), FOREACH, gen_context_recurse, get_bool_property(), instruction_call, orginal_statement, reference_filter(), simd_do_atomize(), and statement_instruction.

Referenced by atomize_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

atomize_statements()

static void atomize_statements ( statement  cs )

static

This function is called for all statements in the code.

Definition at line 352 of file atomizer.c.

{
    // Only a call statement can be atomized
    if (instruction_call_p(statement_instruction(cs)))
    {
        atomize_call_statement(cs);
    }
}

References atomize_call_statement(), instruction_call_p, and statement_instruction.

Referenced by simd_atomizer().

Here is the call graph for this function:

Here is the caller graph for this function:

change_basic_if_needed()

static void change_basic_if_needed ( statement  stat )

static

This function aims at changing the basic size of the left expression of the newly created assign statement.

Definition at line 193 of file atomizer.c.

{
        if( statement_call_p(stat) && ENTITY_ASSIGN_P(call_function(statement_call(stat))))
        {
                int maxWidth = -1;
                expression lExp = EXPRESSION(CAR(call_arguments(statement_call(stat))));
                expression rExp = EXPRESSION(CAR(CDR(call_arguments(statement_call(stat)))));
 
                // Check that the right expression is a call statement
                if(expression_call_p(rExp))
                {
 
                        // Check that the statement can be potentially integrated in a 
                        // SIMD statement 
            // SG: atomizer is no longer limited to sac
                        // if(match_statement(stat) != NIL)
                        {
                                get_type_max_width(syntax_call(expression_syntax(rExp)), &maxWidth);
                        }
 
                        // If the maxWidth of the right expression is smaller than the width 
                        // of the current left expression, then replace the left expression width 
                        // by maxWidth
                        if(maxWidth > 0)
                        {
                                basic lExpBasic = expression_basic(lExp);
                maxWidth=MIN(maxWidth,basic_type_size(lExpBasic));
                        }
                }
        }
}

References basic_type_size(), call_arguments, call_function, CAR, CDR, ENTITY_ASSIGN_P, EXPRESSION, expression_basic(), expression_call_p(), expression_syntax, get_type_max_width(), MIN, statement_call(), statement_call_p(), and syntax_call.

Referenced by simd_insert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

do_expression_reduction()

static bool do_expression_reduction ( statement  s, reduction  r, expression  e  )

static

Definition at line 389 of file atomizer.c.

                                                                            {
    reference redref = reduction_reference(r);
    entity redop = reduction_operator_entity(reduction_op(r));
 
    if(expression_call_p(e)) {
      call ce = expression_call(e);
      if(same_entity_p(call_function(ce), redop)) {
        expression lhs = binary_call_lhs(ce),
                   rhs = binary_call_rhs(ce);
 
        do_expression_reduction(s, r, lhs);
        do_expression_reduction(s, r, rhs);
 
        if(expression_reference_p(lhs) &&
            reference_equal_p(expression_reference(lhs), redref)) {
          update_expression_syntax(e, copy_syntax(expression_syntax(rhs)));
        }
        else if(expression_reference_p(rhs) &&
                 reference_equal_p(expression_reference(rhs), redref)) {
            update_expression_syntax(e, copy_syntax(expression_syntax(lhs)));
        }
        else
        {
            statement snew = make_assign_statement(
                reference_to_expression(copy_reference(redref)),
                MakeBinaryCall(redop,
                    reference_to_expression(copy_reference(redref)),
                    copy_expression(rhs)));
            store_cumulated_reductions(snew,copy_reductions(load_cumulated_reductions(s)));
            update_expression_syntax(e, copy_syntax(expression_syntax(lhs)));
            insert_statement(s, snew, false);
            store_cumulated_reductions(STATEMENT(CAR(statement_block(s))),copy_reductions(load_cumulated_reductions(s)));
        }
        return true;
      }
    }
    return false;
}

References binary_call_lhs, binary_call_rhs, call_function, CAR, copy_expression(), copy_reductions(), copy_reference(), copy_syntax(), expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), expression_syntax, insert_statement(), load_cumulated_reductions(), make_assign_statement(), MakeBinaryCall(), reduction_op, reduction_operator_entity(), reduction_reference, reference_equal_p(), reference_to_expression(), same_entity_p(), STATEMENT, statement_block(), store_cumulated_reductions(), and update_expression_syntax().

Referenced by do_reduction_atomization().

Here is the call graph for this function:

Here is the caller graph for this function:

do_reduction_atomization()

static bool do_reduction_atomization ( statement  s )

static

the reduction must be of the pattern red = red op exp1 op exp2

Definition at line 429 of file atomizer.c.

                                                  {
    list reductions = reductions_list(load_cumulated_reductions(s));
    if(!ENDP(reductions)) {
        FOREACH(REDUCTION,r,reductions) {
            /* the reduction must be of the pattern red = red op exp1 op exp2 */
            reference redref = reduction_reference(r);
            entity redop = reduction_operator_entity(reduction_op(r));
            if(statement_call_p(s)) {
                call c = statement_call(s);
                entity assign = call_function(c);
                if(ENTITY_ASSIGN_P(assign)) {
                    expression lhs = binary_call_lhs(c);
                    if(expression_reference_p(lhs)) {
                        reference  rlhs = expression_reference(lhs);
                        if(reference_equal_p(rlhs,redref)) {
                            expression rhs = binary_call_rhs(c);
                            if(do_expression_reduction(s, r, rhs))
                                update_expression_syntax(rhs, expression_syntax(
                                            MakeBinaryCall(redop,
                                                reference_to_expression(copy_reference(redref)),
                                                copy_expression(rhs))));
                        }
                    }
                }
            }
        }
    }
    return true;
}

References binary_call_lhs, binary_call_rhs, call_function, copy_expression(), copy_reference(), do_expression_reduction(), ENDP, ENTITY_ASSIGN_P, expression_reference(), expression_reference_p(), expression_syntax, FOREACH, load_cumulated_reductions(), MakeBinaryCall(), REDUCTION, reduction_op, reduction_operator_entity(), reduction_reference, reductions_list, reference_equal_p(), reference_to_expression(), statement_call(), statement_call_p(), and update_expression_syntax().

Referenced by reduction_atomization().

Here is the call graph for this function:

Here is the caller graph for this function:

get_type_max_width()

static void get_type_max_width ( call  ca, int *  maxWidth  )

static

This function computes the maximum width of all the variables used in a call.

Definition at line 138 of file atomizer.c.

{
    FOREACH(EXPRESSION, arg,call_arguments(ca))
    {
        syntax s = expression_syntax(arg);
 
        switch(syntax_tag(s))
        {
            case is_syntax_call:
                {
                    call c = syntax_call(s);
 
                    entity op = call_function(c);
                    if ( ENTITY_FIELD_P(op) || ENTITY_POINT_TO_P(op))
                    {
                        basic bas = basic_of_expression(binary_call_rhs(c));
                        *maxWidth=MAX(*maxWidth , basic_type_size(bas));
                        free_basic(bas);
                    }
                    else if (!call_constant_p(c))
                        get_type_max_width(c, maxWidth);
                } break;
 
            case is_syntax_reference:
                {
                    basic bas = basic_of_reference(syntax_reference(s));
                    *maxWidth=MAX(*maxWidth , basic_type_size(bas));
                    free_basic(bas);
                } break;
            case is_syntax_subscript:
                {
                    basic bas = basic_of_expression(subscript_array(syntax_subscript(s)));
                    *maxWidth=MAX(*maxWidth , basic_type_size(bas));
                    free_basic(bas);
                } break;
            case is_syntax_cast:
                {
                    cast ca = syntax_cast(s);
                    type t = cast_type(ca);
                    *maxWidth=MAX(*maxWidth ,type_memory_size(t));
                } break;
                        case is_syntax_sizeofexpression:
                                *maxWidth=MAX(*maxWidth ,DEFAULT_INTEGER_TYPE_SIZE);
                                break;
 
            default:pips_internal_error("syntax_tag %u not supported yet",syntax_tag(s));
 
        }
    }
 
}

References basic_of_expression(), basic_of_reference(), basic_type_size(), binary_call_rhs, call_arguments, call_constant_p, call_function, cast_type, DEFAULT_INTEGER_TYPE_SIZE, ENTITY_FIELD_P, ENTITY_POINT_TO_P, EXPRESSION, expression_syntax, FOREACH, free_basic(), is_syntax_call, is_syntax_cast, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, MAX, pips_internal_error, subscript_array, syntax_call, syntax_cast, syntax_reference, syntax_subscript, syntax_tag, and type_memory_size().

Referenced by change_basic_if_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

patch_constant_size()

static void patch_constant_size ( syntax  s, bool *  patch_all  )

static

Definition at line 62 of file atomizer.c.

{
    switch(syntax_tag(s))
    {
        case is_syntax_call:
            {
                call c = syntax_call(s);
                if(entity_constant_p(call_function(c)) )
                {
                    basic b = variable_basic(type_variable(functional_result(type_functional(entity_type(call_function(c))))));
                       if( basic_int_p(b) && (basic_int(b) == DEFAULT_INTEGER_TYPE_SIZE) )
                            basic_int(b)= 1;
                }
            } break;
        case is_syntax_reference:
            *patch_all = false;
            break;
        default:
            break;
    };
}

References basic_int, basic_int_p, call_function, DEFAULT_INTEGER_TYPE_SIZE, entity_constant_p, entity_type, functional_result, is_syntax_call, is_syntax_reference, syntax_call, syntax_tag, type_functional, type_variable, and variable_basic.

Referenced by simd_atomize_this_expression().

Here is the caller graph for this function:

reduction_atomization()

bool reduction_atomization

(

const char *

module_name

)

prelude

do the job

postlude

Parameters

module_name

odule_name

Definition at line 459 of file atomizer.c.

                                                     {
    /* prelude */
    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_reductions((pstatement_reductions) db_get_memory_resource(DBR_CUMULATED_REDUCTIONS, module_name, true));
 
    /* do the job */
    gen_recurse(get_current_module_statement(),statement_domain,do_reduction_atomization,gen_null);
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, get_current_module_name(), get_current_module_statement());
 
    /* postlude */
    reset_cumulated_reductions();
    reset_current_module_statement();
    reset_current_module_entity();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_reduction_atomization(), gen_null(), gen_recurse, get_current_module_name(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_reductions(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

reference_filter()

static bool reference_filter ( expression  exp, __attribute__((unused)) statement  cs  )

static

Definition at line 298 of file atomizer.c.

{
    if( expression_reference_p(exp) ) {
        if( get_bool_property("SIMD_ATOMIZER_ATOMIZE_REFERENCE") ) return true;
        else {
            reference r = expression_reference(exp);
            FOREACH(EXPRESSION, ind, reference_indices(r)) {
                NORMALIZE_EXPRESSION(ind);
                if(expression_linear_p(ind))
                    gen_recurse_stop(ind);
            }
        }
    }
    if(expression_call_p(exp))
    {
        call c = expression_call(exp);
        entity op = call_function(c);
        return !ENTITY_POINT_TO_P(op) && !ENTITY_FIELD_P(op);
    }
    return true;
}

References call_function, ENTITY_FIELD_P, ENTITY_POINT_TO_P, exp, EXPRESSION, expression_call(), expression_call_p(), expression_linear_p(), expression_reference(), expression_reference_p(), FOREACH, gen_recurse_stop(), get_bool_property(), NORMALIZE_EXPRESSION, and reference_indices.

Referenced by atomize_call_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

sac_make_new_variable()

static entity sac_make_new_variable ( entity  module, basic  b  )

static

Definition at line 267 of file atomizer.c.

{
    entity e = make_new_scalar_variable(module, copy_basic(b));
    AddLocalEntityToDeclarations(e,module,get_current_module_statement());
    return e;
}

References AddLocalEntityToDeclarations(), copy_basic(), get_current_module_statement(), make_new_scalar_variable(), and module.

Referenced by simd_do_atomize().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_atomize_this_expression()

statement simd_atomize_this_expression	(	entity(*)(entity, basic)	create,
		expression	e
	)

returns the assignment statement if moved, or NULL if not.

atomizer.c

it does not make sense to atomize a range...

SG: in case of expression similar to (a+2), if a is a short (or a char ...), the user may expect the result is a short too the C syntax expect 2 is an int set the property to false if you want to override this behavior

force all integer to char, then compute the basic validate only if we can guess the size from something not a constant integer

Definition at line 87 of file atomizer.c.

{
    basic bofe = basic_undefined;
 
    /* it does not make sense to atomize a range...
    */
    if (syntax_range_p(expression_syntax(e))) return NULL;
 
    /* SG: in case of expression similar to (a+2), if a is a short (or a char ...),
     * the user may expect the result is a short too 
     * the C syntax expect 2 is an int
     * set the property to false if you want to override this behavior
     */
    if( get_bool_property("SIMD_OVERRIDE_CONSTANT_TYPE_INFERENCE") )
    {
        expression etemp = copy_expression(e);
        bool patch_all=true;
        /* force all integer to char, then compute the basic
         * validate only if we can guess the size from something not a constant integer
         */
        gen_context_recurse(etemp, &patch_all, syntax_domain, gen_true2, patch_constant_size);
        if( !patch_all )
            bofe=basic_of_expression(etemp);
        free_expression(etemp);
    }
 
    if(basic_undefined_p(bofe) )
        bofe = basic_of_expression(e);
 
    if(!basic_undefined_p(bofe)) {
        if (!basic_overloaded_p(bofe))
        {
            entity newvar = (*create)(get_current_module_entity(), bofe);
            AddEntityToCurrentModule(newvar);
            expression rhs = make_expression(expression_syntax(e), normalized_undefined);
            normalize_all_expressions_of(rhs);
            statement assign = make_assign_statement(entity_to_expression(newvar),rhs);
            expression_syntax(e) = make_syntax_reference( make_reference(newvar, NIL));
 
            return assign;
        }
 
        free_basic(bofe);
    }
    return NULL;
}

References AddEntityToCurrentModule(), basic_of_expression(), basic_overloaded_p, basic_undefined, basic_undefined_p, copy_expression(), entity_to_expression(), expression_syntax, free_basic(), free_expression(), gen_context_recurse, gen_true2(), get_bool_property(), get_current_module_entity(), make_assign_statement(), make_expression(), make_reference(), make_syntax_reference(), NIL, normalize_all_expressions_of(), normalized_undefined, patch_constant_size(), syntax_domain, and syntax_range_p.

Referenced by atomize_condition(), and simd_do_atomize().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_atomizer()

bool simd_atomizer

(

char *

mod_name

)

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 361 of file atomizer.c.

{
    /* get the resources */
    statement mod_stmt = (statement)
        db_get_memory_resource(DBR_CODE, mod_name, true);
 
    set_current_module_statement(mod_stmt);
    set_current_module_entity(module_name_to_entity(mod_name));
 
    debug_on("SIMD_ATOMIZER_DEBUG_LEVEL");
 
 
    /* Now do the job */
    gen_recurse(mod_stmt, statement_domain, gen_true, atomize_statements);
 
    /* Reorder the module, because new statements have been added */  
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
 
    /* update/release resources */
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References atomize_statements(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

simd_do_atomize()

static void simd_do_atomize ( expression  ce, statement  cs  )

static

If the current call is not an assign call, let's atomize the current argument sg: also try to be smart and make reduction appear if any

Definition at line 275 of file atomizer.c.

{
        syntax s = expression_syntax(ce);
        statement stat =statement_undefined;
 
        // Atomize expression only if this is a call expression
        if(syntax_call_p(s))
        {
                call cc = syntax_call(s);
 
                // Atomize expression only if the call is not a constant
                if(FUNC_TO_ATOMIZE_P(cc))
                {
                        /* If the current call is not an assign call,
                         * let's atomize the current argument
             * sg: also try to be smart and make reduction appear if any
             */
                        
                        if( (stat = simd_atomize_this_expression(sac_make_new_variable, ce)) )
                                simd_insert_statement(cs, stat);
                }
        }
}

References expression_syntax, FUNC_TO_ATOMIZE_P, sac_make_new_variable(), simd_atomize_this_expression(), simd_insert_statement(), statement_undefined, syntax_call, and syntax_call_p.

Referenced by atomize_call_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_insert_statement()

static void simd_insert_statement ( statement  cs, statement  stat  )

static

This function insert stat before orginal_statement in the code.

Definition at line 227 of file atomizer.c.

{
        change_basic_if_needed(stat);
        // If cs is already a sequence, we just need to insert stat in cs
        if(instruction_sequence_p(statement_instruction(cs)))
        {
                instruction_block(statement_instruction(cs)) = gen_insert_before(stat,
                                orginal_statement,
                                instruction_block(statement_instruction(cs)));
        }
        // If cs is not a sequence, we have to create one sequence composed of
        // cs then orginal_statement
        else
        {
                statement_label(stat) = statement_label(cs);
 
                orginal_statement = make_statement(entity_empty_label(), 
                                statement_number(cs),
                                statement_ordering(cs),
                                statement_comments(cs),
                                statement_instruction(cs),
                                statement_declarations(cs),
                                NULL,
                                statement_extensions(cs), make_synchronization_none());
 
                statement_instruction(cs) =
                        make_instruction_block(CONS(STATEMENT, stat,
                                                CONS(STATEMENT,
                                                        orginal_statement,
                                                        NIL)));
 
                statement_label(cs) = entity_empty_label();
                statement_number(cs) = STATEMENT_NUMBER_UNDEFINED;
                statement_ordering(cs) = STATEMENT_ORDERING_UNDEFINED;
                statement_comments(cs) = empty_comments;
                statement_extensions(cs) = empty_extensions ();
        }
}

References change_basic_if_needed(), CONS, empty_comments, empty_extensions(), entity_empty_label(), gen_insert_before(), instruction_block, instruction_sequence_p, make_instruction_block(), make_statement(), make_synchronization_none(), NIL, orginal_statement, STATEMENT, statement_comments, statement_declarations, statement_extensions, statement_instruction, statement_label, statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, and STATEMENT_ORDERING_UNDEFINED.

Referenced by simd_do_atomize().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

current_lhs

expression current_lhs = expression_undefined

static

Definition at line 83 of file atomizer.c.

Referenced by atomize_call_statement().

orginal_statement

statement orginal_statement = NULL

static

An atomizer that uses the one made by Fabien Coelho for HPFC, and is in fact just a hacked version of the one made by Ronan Keryell...

Definition at line 58 of file atomizer.c.

Referenced by atomize_call_statement(), and simd_insert_statement().