computation_intensity.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 "complexity_ri.h"
#include "text.h"
#include "ri-util.h"
#include "effects-util.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "text-util.h"
#include "database.h"
#include "pipsdbm.h"
#include "resources.h"
#include "properties.h"
#include "complexity.h"
#include "accel-util.h"

Include dependency graph for computation_intensity.c:

Go to the source code of this file.

Data Structures
struct	computation_intensity_param

Functions
static void	init_computation_intensity_param (computation_intensity_param *p)
	read properties to initialize cost model More...
static bool	do_computation_intensity (statement s, computation_intensity_param *p)
	a loop statement is considered as compute intensive if transfer costs a re greater than execution cost More...
bool	computation_intensity (const char *module_name)
	mark all loops (do / for /while) that have sufficient computation intensity with a pragma, suitable for treatment by other phases. More...

Function Documentation

computation_intensity()

bool computation_intensity

(

const char *

module_name

)

mark all loops (do / for /while) that have sufficient computation intensity with a pragma, suitable for treatment by other phases.

computation_intensity.c

The computation intensity is derived from the complexity and the memory footprint. It assumes the cost model: execution_time = startup_overhead + memory_footprint / bandwidth + complexity / frequency

init stuff

do it now !

validate changes

reset

Parameters

module_name

odule_name

Definition at line 123 of file computation_intensity.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_complexity_map( (statement_mapping) db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
 
    computation_intensity_param p;
    init_computation_intensity_param(&p);
 
    /* do it now ! */
    gen_context_recurse(get_current_module_statement(), &p,
            statement_domain, do_computation_intensity, gen_null2);
 
    /* validate changes */
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /* reset */
    reset_current_module_entity();
    reset_current_module_statement();
    reset_complexity_map();
    reset_cumulated_rw_effects();
 
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_computation_intensity(), gen_context_recurse, gen_null2(), get_current_module_statement(), init_computation_intensity_param(), module_name(), module_name_to_entity(), reset_complexity_map(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_complexity_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

do_computation_intensity()

static bool do_computation_intensity ( statement  s, computation_intensity_param *  p  )

static

a loop statement is considered as compute intensive if transfer costs a re greater than execution cost

compute instruction contribution to execution time

compute transfer contribution to execution time

now let's compare them, using their difference

heuristic to check the behavior at the infinite: assumes all variables are positives, take the higher degree monomial and decide upon its coefficient

seems a computation intensive loop !

Definition at line 72 of file computation_intensity.c.

                                                                                  {
    if(statement_loop_p(s)) {
        list regions = load_cumulated_rw_effects_list(s);
        complexity comp = load_statement_complexity(s);
        /* compute instruction contribution to execution time */
        Ppolynome instruction_time = polynome_dup(complexity_polynome(comp));
        polynome_scalar_mult(&instruction_time,1.f/p->frequency);
 
        /* compute transfer contribution to execution time */
        Ppolynome transfer_time = POLYNOME_NUL;
        FOREACH(REGION,reg,regions) {
            Ppolynome reg_footprint= region_enumerate(reg); // may be we should use the rectangular hull ?
            polynome_add(&transfer_time,reg_footprint);
            polynome_rm(&reg_footprint);
        }
        polynome_scalar_mult(&transfer_time,1.f/p->bandwidth);
        polynome_scalar_add(&transfer_time,p->startup_overhead);
 
        /* now let's compare them, using their difference */
        polynome_negate(&transfer_time);
        polynome_add(&instruction_time,transfer_time);
        polynome_rm(&transfer_time);
        /* heuristic to check the behavior at the infinite:
         * assumes all variables are positives,
         * take the higher degree monomial
         * and decide upon its coefficient
         */
        int max_degree = polynome_max_degree(instruction_time);
        float coeff=-1.f;
        for(Ppolynome p = instruction_time; !POLYNOME_NUL_P(p); p = polynome_succ(p)) {
            int curr_degree =  (int)vect_sum(monome_term(polynome_monome(p)));
            if(curr_degree == max_degree) {
                coeff = monome_coeff(polynome_monome(p));
                break;
            }
        }
        polynome_rm(&instruction_time);
        /* seems a computation intensive loop ! */
        if(coeff> 0) {
            add_pragma_str_to_statement(s,p->pragma,true);
            return false;
        }
    }
    return true;
}

References add_pragma_str_to_statement(), computation_intensity_param::bandwidth, complexity_polynome(), FOREACH, computation_intensity_param::frequency, int, load_cumulated_rw_effects_list(), load_statement_complexity(), monome_coeff, monome_term, polynome_add(), polynome_dup(), polynome_max_degree(), polynome_monome, polynome_negate(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_rm(), polynome_scalar_add(), polynome_scalar_mult(), polynome_succ, computation_intensity_param::pragma, REGION, region_enumerate(), computation_intensity_param::startup_overhead, statement_loop_p(), and vect_sum().

Referenced by computation_intensity().

Here is the call graph for this function:

Here is the caller graph for this function:

init_computation_intensity_param()

static void init_computation_intensity_param ( computation_intensity_param *  p )

static

read properties to initialize cost model

Definition at line 62 of file computation_intensity.c.

                                                                             {
    p->startup_overhead=get_int_property("COMPUTATION_INTENSITY_STARTUP_OVERHEAD");
    p->bandwidth=get_int_property("COMPUTATION_INTENSITY_BANDWIDTH");
    p->frequency=get_int_property("COMPUTATION_INTENSITY_FREQUENCY");
    p->pragma=get_string_property("COMPUTATION_INTENSITY_PRAGMA");
}

References computation_intensity_param::bandwidth, computation_intensity_param::frequency, get_int_property(), get_string_property(), computation_intensity_param::pragma, and computation_intensity_param::startup_overhead.

Referenced by computation_intensity().

Here is the call graph for this function:

Here is the caller graph for this function: