strip_mine.c File Reference

#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "pipsdbm.h"
#include "properties.h"
#include "ri.h"
#include "text.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "text-util.h"
#include "control.h"
#include "conversion.h"
#include "transformations.h"

Include dependency graph for strip_mine.c:

Go to the source code of this file.

Functions
statement	loop_strip_mine (statement loop_statement, int chunk_size, int chunk_number)
	loop_strip_mine(): More...
static statement	loop_chunk_size_and_strip_mine (list lls, __attribute__((unused)) bool(*unused)(statement))
	Hmmm... More...
bool	strip_mine (const string mod_name)
	Top-level function. More...

Variables
entity	selected_label
	Interface with pipsmake for interactive loop transformations: loop interchange, hyperplane method,... More...
char *	current_module_name

Function Documentation

loop_chunk_size_and_strip_mine()

static statement loop_chunk_size_and_strip_mine ( list  lls, __attribute__((unused)) bool(*)(statement)  unused  )

static

Hmmm...

I am not sure it is a good idea to put the user_request()s here. Did the author want to be able to apply loop_chunk_size_and_strip_mine() several times on different loops with different strip mining parameters?

Get the strip_mining kind from the user

Get the strip_mining factor from the user

Return the statement unchanged:

Definition at line 165 of file strip_mine.c.

{
 
    string resp;
    int kind, factor;
    statement stmt, new_s;
    int chunk_size = -1;
    int chunk_number = -1;
 
    stmt = STATEMENT(CAR(gen_last(lls)));
 
    /* Get the strip_mining kind from the user */
    kind=get_int_property("STRIP_MINE_KIND");
    if( kind!=0 && kind!=1 ) {
        resp = user_request("Type of strip-mining:\n - in fixed-size chunks "
                "(enter 0)\n - in a fixed number of chunks (enter 1)");
        if ( empty_string_p(resp) ) {
            goto cancel;
        }
        else {
            if(sscanf(resp, "%d", &kind)!=1 || (kind!= 0 && kind !=1)) {
                pips_user_error("strip_mining kind should be either 0 or 1!\n");
            }
        }
    }
 
    factor=get_int_property("STRIP_MINE_FACTOR");
    if(factor<=1) {
 
        /* Get the strip_mining factor from the user */
        resp = user_request("What's the stripe %s?\n"
                "(choose integer greater or egal to 2): ", 
                kind ? "number" : "size");
        if ( empty_string_p(resp) ) {
            goto cancel;
        }
        else {
            if(sscanf(resp, "%d", &factor)!=1 || factor <= 1) {
                user_error("strip_mine", 
                        "stripe size or number should be greater than 2\n");
            }
        }
    }
 
    if(kind==0) {
        chunk_size = factor;
        chunk_number = -1;
    }
    else {
        chunk_size = -1;
        chunk_number = factor;
    }
 
    pips_debug(1,"strip mine in %d chunks of size %d \n",
            chunk_number, chunk_size);
    new_s = loop_strip_mine(stmt,chunk_size,chunk_number);
    return(new_s);
 
cancel:
    user_log("Strip mining has been cancelled.\n");
 
    /* Return the statement unchanged: */
    return stmt;
}

References cancel, CAR, empty_string_p(), gen_last(), get_int_property(), loop_strip_mine(), pips_debug, pips_user_error, STATEMENT, user_error, user_log(), and user_request().

Referenced by strip_mine().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_strip_mine()

statement loop_strip_mine	(	statement	loop_statement,
		int	chunk_size,
		int	chunk_number
	)

loop_strip_mine():

strip_mine.c

Sharing is (theoretically) avoided when the AST is built

Assumption:

• a loop body can be a loop (no need for a block with one statement, a loop)

compute the expression for the chunk size

make sure that the outer loop does not use a continue that will end up in the inner loop body

derive a new loop index (FI: only one name :-(

build the inner loop preserving the initial index set

update the outer loop

Parameters

loop_statement	oop_statement
chunk_size	hunk_size
chunk_number	hunk_number

Definition at line 64 of file strip_mine.c.

{
    loop l = instruction_loop(statement_instruction(loop_statement));
    loop new_l = loop_undefined;
    statement new_s = statement_undefined;
    expression size = expression_undefined;
    expression sizem1 = expression_undefined;
    expression lb = range_lower(loop_range(l));
    expression ub = range_upper(loop_range(l));
    entity index = loop_index(l);
    statement b = loop_body(l);
    entity new_index = entity_undefined;
 
    debug(9, "loop_strip_mine", "begin: chunk_size = %d,chunk_number = %d\n",
          chunk_size, chunk_number);
    pips_assert("loop_strip_mine", ( chunk_size > 1 && chunk_number == -1 )
                ||
                (chunk_size == -1 && chunk_number > 1) );
 
    if(loop_increment_value(l) != 1)
        user_error("loop_strip_mine",
                   "Loop increment has to be one for strip-mining!\n");
 
    if(get_debug_level()>=9) {
      print_statement(loop_statement);
      pips_assert("loop_strip_mine", statement_consistent_p(loop_statement));
    }
 
    /* compute the expression for the chunk size */
    if(chunk_size==-1) {
        expression e_number = int_to_expression(chunk_number);
 
        size = make_op_exp(MINUS_OPERATOR_NAME, copy_expression(ub), copy_expression(lb));
        size = make_op_exp(PLUS_OPERATOR_NAME, size, copy_expression(e_number));
        size = make_op_exp(DIVIDE_OPERATOR_NAME, size, e_number);
        sizem1 = make_op_exp(MINUS_OPERATOR_NAME, copy_expression(size), int_to_expression(1));
    }
    else {
        size = int_to_expression(chunk_size);
        sizem1 = int_to_expression(chunk_size-1);
    }
    ifdebug(9) {
      pips_debug(8, "size = ");
      print_expression(size);
      pips_debug(8, "sizem1 = ");
      print_expression(sizem1);
    }
    
    /* make sure that the outer loop does not use a continue that will
    end up in the inner loop body */
    loop_label(l)=entity_empty_label();
 
    /* derive a new loop index (FI: only *one* name :-( */
    new_index = make_new_index_entity(index, "_1");
    AddEntityToDeclarations(new_index, get_current_module_entity());
 
    /* build the inner loop preserving the initial index set */
    expression fst_min_param=MakeBinaryCall(entity_intrinsic("+"),entity_to_expression(new_index),sizem1);
    expression snd_min_parameter=copy_expression(ub);
    expression min_exp = 
        MakeBinaryCall(entity_intrinsic(MIN_OPERATOR_NAME),fst_min_param,snd_min_parameter);
    new_l = make_loop(index,
                      make_range(entity_to_expression(new_index),
                  min_exp,
                                 int_to_expression(1)),
                      b,
                      entity_empty_label(),
                      execution_sequential_p(loop_execution(l)) ?
                      make_execution(is_execution_sequential, UU):
                      make_execution(is_execution_parallel, UU),
                      NIL);
 
    new_s = instruction_to_statement(make_instruction(is_instruction_loop, new_l));
 
    ifdebug(8) {
      pips_debug(8, "new inner loop:");
      print_statement(new_s);
      pips_assert("loop_strip_mine", statement_consistent_p(new_s));
    }
 
    /* update the outer loop */
    loop_index(l) = new_index;
    range_increment(loop_range(l)) = copy_expression(size);
    loop_body(l) = new_s;
 
    ifdebug(8) {
      print_statement(loop_statement);
      pips_assert("loop_statement consistent_p", statement_consistent_p(loop_statement));
    }
 
    pips_debug(8, "end\n");
    return(loop_statement);
}

References AddEntityToDeclarations(), copy_expression(), debug(), DIVIDE_OPERATOR_NAME, entity_empty_label(), entity_intrinsic(), entity_to_expression(), entity_undefined, execution_sequential_p, expression_undefined, get_current_module_entity(), get_debug_level(), ifdebug, instruction_loop, instruction_to_statement(), int_to_expression(), is_execution_parallel, is_execution_sequential, is_instruction_loop, loop_body, loop_execution, loop_increment_value(), loop_index, loop_label, loop_range, loop_undefined, make_execution(), make_instruction(), make_loop(), make_new_index_entity(), make_op_exp(), make_range(), MakeBinaryCall(), MIN_OPERATOR_NAME, MINUS_OPERATOR_NAME, NIL, pips_assert, pips_debug, PLUS_OPERATOR_NAME, print_expression(), print_statement(), range_increment, range_lower, range_upper, statement_consistent_p(), statement_instruction, statement_undefined, user_error, and UU.

Referenced by do_kernelize(), and loop_chunk_size_and_strip_mine().

Here is the call graph for this function:

Here is the caller graph for this function:

strip_mine()

bool strip_mine

(

const string

mod_name

)

Top-level function.

Get the loop label form the user

DBR_CODE will be changed: argument "pure" should take false but this would be useless since there is only one version of code; a new version will be put back in the data base after strip_mineing

Reorder the module, because new statements have been generated.

Parameters

mod_name

od_name

Definition at line 233 of file strip_mine.c.

{
    entity module = module_name_to_entity(mod_name);
    statement mod_stmt;
    const char *lp_label=NULL;
    bool return_status;
 
    debug_on("STRIP_MINE_DEBUG_LEVEL");
 
    /* Get the loop label form the user */
    lp_label=get_string_property_or_ask("LOOP_LABEL","Which loop do you want to strip_mine?\n" "(give its label): ");
    if (lp_label[0] == '\0') {
        user_log("Strip mining has been cancelled.\n");
        return_status = false;
    }
    else {
        selected_label = find_label_entity(mod_name, lp_label);
        if (entity_undefined_p(selected_label)) {
            user_error("strip_mine", "loop label `%s' does not exist\n", lp_label);
        }
 
        set_current_module_entity(module);
 
        /* DBR_CODE will be changed: argument "pure" should take false but
           this would be useless since there is only *one* version of code;
           a new version will be put back in the data base after
           strip_mineing */
        mod_stmt = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
        set_current_module_statement(mod_stmt);
 
        look_for_nested_loop_statements(mod_stmt, loop_chunk_size_and_strip_mine, selected_loop_p);
 
        /* Reorder the module, because new statements have been generated. */
        module_reorder(mod_stmt);
 
        reset_current_module_entity();
        reset_current_module_statement();
 
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
        return_status = true;
    }
 
    debug(2,"strip_mine","done for %s\n", mod_name);
    debug_off();
 
    return return_status;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, entity_undefined_p, find_label_entity(), get_string_property_or_ask(), look_for_nested_loop_statements(), loop_chunk_size_and_strip_mine(), module, module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), selected_label, selected_loop_p(), set_current_module_entity(), set_current_module_statement(), user_error, and user_log().

Here is the call graph for this function:

Variable Documentation

current_module_name

char* current_module_name

extern

selected_label

entity selected_label

extern

Interface with pipsmake for interactive loop transformations: loop interchange, hyperplane method,...

Definition at line 61 of file interactive_loop_transformation.c.

Referenced by strip_mine().