gpu_promote_sequential.c File Reference

Avoid useless data transfert by promoting sequential code on GPU. More...

#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "kernel_memory_mapping.h"
#include "effects.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "semantics.h"
#include "effects-util.h"
#include "text.h"
#include "pipsdbm.h"
#include "resources.h"
#include "properties.h"
#include "misc.h"
#include "control.h"
#include "callgraph.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "text-util.h"
#include "parser_private.h"
#include "preprocessor.h"
#include "transformer.h"
#include "accel-util.h"

Include dependency graph for gpu_promote_sequential.c:

Go to the source code of this file.

Functions
static statement	promote_statement (list promoted_stmts, loop l)
void	gpu_promote_sequential_on_sequence (sequence seq, loop l)
	Operate on a sequence and promote all sequential code in a trivial parallel loop. More...
static bool	gpu_promote_sequential_walker_in (loop l)
void	gpu_promote_sequential_on_statement (statement s)
bool	gpu_promote_sequential (const char *module_name)

Detailed Description

Avoid useless data transfert by promoting sequential code on GPU.

Author

Mehdi Amini mehdi.nosp@m..ami.nosp@m.ni@hp.nosp@m.c-pr.nosp@m.oject.nosp@m..com

Definition in file gpu_promote_sequential.c.

Function Documentation

gpu_promote_sequential()

bool gpu_promote_sequential

(

const char *

module_name

)

Initialize set for each statement

Parameters

module_name

odule_name

Definition at line 143 of file gpu_promote_sequential.c.

                                                     {
  statement module_stat = (statement)db_get_memory_resource(DBR_CODE,
                                                            module_name,
                                                            true);
  set_current_module_statement(module_stat);
  set_current_module_entity(local_name_to_top_level_entity(module_name));
 
  debug_on("GPU_PROMOTE_SEQUENTIAL_DEBUG_LEVEL");
 
  /* Initialize set for each statement */
  gpu_promote_sequential_on_statement(module_stat);
 
  debug_off();
 
  module_reorder(module_stat);
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,
      module_name,
      module_stat);
 
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
 
 
 
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gpu_promote_sequential_on_statement(), local_name_to_top_level_entity(), module_name(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), and set_current_module_statement().

Here is the call graph for this function:

gpu_promote_sequential_on_sequence()

void gpu_promote_sequential_on_sequence	(	sequence	seq,
		loop	l
	)

Operate on a sequence and promote all sequential code in a trivial parallel loop.

gpu_promote_sequential.c

The heuristic that trigger the promotion is quite simple at that time, all sequential code is promoted if a parallel loop is present in the sequence

Parameters

seq	is the sequence on which to operate @loop l is an optionnal param that give the enclosing loop

Parameters

seq

eq

Definition at line 83 of file gpu_promote_sequential.c.

                                                              {
  list stmts = sequence_statements(seq);
 
  // Try to find a parallel loop in the sequence
  bool found_parallel_loop_p = false;
  FOREACH(statement,s,stmts) {
    if(parallel_loop_statement_p(s)) {
      found_parallel_loop_p = true;
      break;
    }
  }
 
  if(found_parallel_loop_p) {
    list new_stmts = NIL;
    list promoted_stmts = NIL;
    FOREACH(statement,s,stmts) {
      if(!parallel_loop_statement_p(s)) {
        if(!empty_statement_or_continue_p(s)) {
          ifdebug(2) {
            pips_debug(2,"Promote statement :");
            print_statement(s);
          }
 
          promoted_stmts = CONS(statement,s,promoted_stmts);
        }
      } else if(promoted_stmts) {
        promoted_stmts = gen_nreverse(promoted_stmts);
        statement promoted = promote_statement(promoted_stmts, l);
        new_stmts = CONS(statement,promoted,CONS(statement,s,new_stmts));
        promoted_stmts = NIL;
 
        ifdebug(2) {
          pips_debug(2,"Promote statements in loop :");
          print_statement(promoted);
        }
      }
    }
    if(promoted_stmts) {
      promoted_stmts = gen_nreverse(promoted_stmts);
      statement promoted = promote_statement(promoted_stmts, l);
      new_stmts = CONS(statement,promoted,new_stmts);
    }
    sequence_statements(seq) = gen_nreverse(new_stmts); // FIXME Free old sequence
  }
}

References CONS, empty_statement_or_continue_p(), FOREACH, gen_nreverse(), ifdebug, NIL, parallel_loop_statement_p(), pips_debug, print_statement(), promote_statement(), and sequence_statements.

Referenced by gpu_promote_sequential_walker_in().

Here is the call graph for this function:

Here is the caller graph for this function:

gpu_promote_sequential_on_statement()

void gpu_promote_sequential_on_statement

(

statement

s

)

Definition at line 139 of file gpu_promote_sequential.c.

                                                      {
  gen_recurse(s,loop_domain,gpu_promote_sequential_walker_in,gen_null);
}

References gen_null(), gen_recurse, gpu_promote_sequential_walker_in(), and loop_domain.

Referenced by gpu_promote_sequential().

Here is the call graph for this function:

Here is the caller graph for this function:

gpu_promote_sequential_walker_in()

static bool gpu_promote_sequential_walker_in ( loop  l )

static

Definition at line 129 of file gpu_promote_sequential.c.

                                                     {
  if(loop_sequential_p(l)) {
    statement body = loop_body(l);
    if(statement_sequence_p(body)) {
      gpu_promote_sequential_on_sequence(statement_sequence(body),l);
    }
  }
  return true;
}

References gpu_promote_sequential_on_sequence(), loop_body, loop_sequential_p(), statement_sequence(), and statement_sequence_p().

Referenced by gpu_promote_sequential_on_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

promote_statement()

static statement promote_statement ( list  promoted_stmts, loop  l  )

static

Definition at line 59 of file gpu_promote_sequential.c.

                                                                {
  promoted_stmts = gen_nreverse(promoted_stmts);
  entity loop_idx = make_new_scalar_variable(get_current_module_entity(),
                                             make_basic(is_basic_int, (void *) 4));
  statement promoted = make_new_loop_statement(loop_idx,
                                               int_to_expression(0),
                                               int_to_expression(0),
                                               int_to_expression(1),
                                               make_block_statement(promoted_stmts),
                                               make_execution_parallel());
  if(!loop_undefined_p(l)) {
    loop_locals(l) = CONS(entity,loop_idx,loop_locals(l));
  }
  return promoted;
}

References CONS, gen_nreverse(), get_current_module_entity(), int_to_expression(), is_basic_int, loop_locals, loop_undefined_p, make_basic(), make_block_statement(), make_execution_parallel(), make_new_loop_statement(), and make_new_scalar_variable().

Referenced by gpu_promote_sequential_on_sequence().

Here is the call graph for this function:

Here is the caller graph for this function: