localize_memory.c File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "effects-util.h"
#include "misc.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "control.h"
#include "callgraph.h"
#include "pipsdbm.h"
#include "resources.h"

Include dependency graph for localize_memory.c:

Go to the source code of this file.

Functions
static bool	mark_loop_to_outline (const statement s)
static void	gpu_ify_statement (statement s, int depth)
bool	old__gpu_ify (const string module_name)

Variables
list	loop_nests_to_outline
	Store the loop nests found that meet the spec to be executed on a GPU. More...

Function Documentation

gpu_ify_statement()

static void gpu_ify_statement ( statement  s, int  depth  )

static

First outline the innermost code (the kernel itself) to avoid spoiling its memory effects if we start with the outermost code first:

Definition at line 60 of file localize_memory.c.

                                          {
  ifdebug(1) {
    pips_debug(1, "Parallel loop-nest of depth %d\n", depth);
    print_statement(s);
  }
  /* First outline the innermost code (the kernel itself) to avoid
     spoiling its memory effects if we start with the outermost code
     first: */
  list sk = CONS(STATEMENT,
                 perfectly_nested_loop_to_body_at_depth(s, depth),
                 NIL);
  outliner(build_new_top_level_module_name("kernel_wrapper",false), sk);
 
  // Outline the kernel launcher:
  list sl = CONS(STATEMENT, s, NIL);
  outliner(build_new_top_level_module_name("kernel_launcher",false), sl);
}

References build_new_top_level_module_name(), CONS, depth, ifdebug, NIL, outliner(), perfectly_nested_loop_to_body_at_depth(), pips_debug, print_statement(), and STATEMENT.

Referenced by old__gpu_ify().

Here is the call graph for this function:

Here is the caller graph for this function:

mark_loop_to_outline()

static bool mark_loop_to_outline ( const statement  s )

static

An interesting loop must be parallel first...

We recurse on statements instead of loops in order to pick informations on the statement itself, such as pragmas

Since we only outline outermost loop-nest, stop digging further in this statement:

Definition at line 34 of file localize_memory.c.

                                        {
  /* An interesting loop must be parallel first...
 
     We recurse on statements instead of loops in order to pick
     informations on the statement itself, such as pragmas
  */
  int parallel_loop_nest_depth = depth_of_parallel_perfect_loop_nest(s);
  ifdebug(3) {
    pips_debug(1, "Statement %td with // depth %d\n", statement_number(s),
               parallel_loop_nest_depth);
    print_statement(s);
  }
  if (parallel_loop_nest_depth > 0) {
    // Register the loop-nest (note the list is in the reverse order):
    loop_nests_to_outline = CONS(STATEMENT, s, loop_nests_to_outline);
    /* Since we only outline outermost loop-nest, stop digging further in
       this statement: */
    pips_debug(1, "Statement %td marked to be outlined\n", statement_number(s));
    return false;
  }
  // This statement is not a parallel loop, go on digging:
  return true;
}

References CONS, depth_of_parallel_perfect_loop_nest(), ifdebug, loop_nests_to_outline, pips_debug, print_statement(), STATEMENT, and statement_number.

Referenced by old__gpu_ify().

Here is the call graph for this function:

Here is the caller graph for this function:

old__gpu_ify()

bool old__gpu_ify

(

const string

module_name

)

Outline the previous marked loop nests. First put the statements to outline in the good order:

Definition at line 79 of file localize_memory.c.

                                            {
  // Use this module name and this environment variable to set
  statement module_statement = PIPS_PHASE_PRELUDE(module_name,
                                                  "GPU_IFY_DEBUG_LEVEL");
 
  // Get the effects and use them:
  set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS,module_name,true));
 
  // Initialize the loop nest set to outline to the empty set yet:
  loop_nests_to_outline = NIL;
 
  // Mark interesting loops:
  gen_recurse(module_statement,
              statement_domain, mark_loop_to_outline, gen_identity);
 
  /* Outline the previous marked loop nests.
     First put the statements to outline in the good order: */
  loop_nests_to_outline = gen_nreverse(loop_nests_to_outline);
  FOREACH(STATEMENT, s, loop_nests_to_outline) {
    // We could have stored the depth, but it complexify the code...
    gpu_ify_statement(s, depth_of_parallel_perfect_loop_nest(s));
  }
 
  gen_free_list(loop_nests_to_outline);
 
  // No longer use effects:
  reset_cumulated_rw_effects();
 
  // We may have outline some code, so recompute the callees:
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
                         compute_callees(get_current_module_statement()));
 
  // Put back the new statement module
  PIPS_PHASE_POSTLUDE(module_statement);
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, depth_of_parallel_perfect_loop_nest(), FOREACH, gen_free_list(), gen_identity(), gen_nreverse(), gen_recurse, get_current_module_statement(), gpu_ify_statement(), loop_nests_to_outline, mark_loop_to_outline(), module_name(), module_statement, NIL, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, reset_cumulated_rw_effects(), set_cumulated_rw_effects(), STATEMENT, and statement_domain.

Here is the call graph for this function:

Variable Documentation

loop_nests_to_outline

list loop_nests_to_outline

Store the loop nests found that meet the spec to be executed on a GPU.

Use a list and not a set or hash_map to have always the same order

Definition at line 30 of file localize_memory.c.

Referenced by mark_loop_to_outline(), and old__gpu_ify().