starpu_pragma_generation.c File Reference

Task generation. More...

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "effects-util.h"
#include "gpu.h"
#include "accel-util.h"
#include "text.h"
#include "pipsdbm.h"
#include "pipsmake.h"
#include "resources.h"
#include "properties.h"
#include "misc.h"
#include "control.h"
#include "callgraph.h"
#include "effects.h"
#include "effects-simple.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "preprocessor.h"
#include "expressions.h"
#include "text-util.h"
#include "parser_private.h"

Include dependency graph for starpu_pragma_generation.c:

Go to the source code of this file.

Data Structures
struct	context_address_of_entity

Functions
static statement	get_statement_pragma_register (entity e, bool address_of)
static statement	get_statement_pragma_init ()
static statement	get_statement_pragma_shutdown ()
bool	address_of_entity_p (call c, struct context_address_of_entity *context)
static bool	address_of_variable_is_taken (void *start, entity e)
static void	scalar_to_array (reference r, entity e)
static bool	add_pragma_to_sequence (sequence seq)
bool	array_bounded_p (entity e)
bool	add_shutdown_pragma_to_return (statement s)
bool	generate_starpu_pragma (char *module_name)

Detailed Description

Task generation.

Author

Mehdi Amini mehdi.nosp@m..ami.nosp@m.ni@si.nosp@m.lkan.nosp@m..com

Definition in file starpu_pragma_generation.c.

Function Documentation

add_pragma_to_sequence()

static bool add_pragma_to_sequence ( sequence  seq )

static

Definition at line 108 of file starpu_pragma_generation.c.

                                                 {
  list stmts = sequence_statements(seq);
  list registered_entities = NIL;
  list last_stmt = NIL;
  for( ; !ENDP(stmts) ;  POP(stmts) ) {
    statement s = STATEMENT(CAR(stmts));
    last_stmt = stmts;
    if(declaration_statement_p(s)) {
      FOREACH(entity,e,statement_declarations(s)) {
        if(entity_array_p(e)) {
          statement pragma = get_statement_pragma_register(e,false);
          CDR(stmts) = CONS(statement, pragma, CDR(stmts) );
          POP(stmts);
          registered_entities = CONS(entity,e,registered_entities);
        } else if(address_of_variable_is_taken(seq,e)) {
          type t = entity_type(e);
          pips_assert("is a variable",type_variable_p(t));
          variable v = type_variable(t);
          pips_assert("scalar !", ENDP(variable_dimensions(v)));
          dimension d = make_dimension(entity_to_expression(make_integer_constant_entity(0)),
                                       entity_to_expression(make_integer_constant_entity(0)),
                                       NIL);
          variable_dimensions(v) = CONS(dimension,d,NIL);
          gen_context_recurse(seq, e, reference_domain, gen_true2, scalar_to_array);
          statement pragma = get_statement_pragma_register(e,false);
          CDR(stmts) = CONS(statement, pragma, CDR(stmts) );
          POP(stmts);
 
          registered_entities = CONS(entity,e,registered_entities);
        }
      }
    }
  }
  FOREACH(entity,e,registered_entities) {
    statement pragma = make_plain_continue_statement();
    string str;
    asprintf(&str,"starpu unregister %s",entity_user_name(e));
    add_pragma_str_to_statement(pragma,str,false);
    CDR(last_stmt) = CONS(statement, pragma, NIL );
    POP(last_stmt);
  }
  return true;
}

References add_pragma_str_to_statement(), address_of_variable_is_taken(), asprintf, CAR, CDR, CONS, declaration_statement_p(), context_address_of_entity::e, ENDP, entity_array_p(), entity_to_expression(), entity_type, entity_user_name(), FOREACH, gen_context_recurse, gen_true2(), get_statement_pragma_register(), make_dimension(), make_integer_constant_entity(), make_plain_continue_statement(), NIL, pips_assert, POP, reference_domain, scalar_to_array(), sequence_statements, STATEMENT, statement_declarations, type_variable, type_variable_p, and variable_dimensions.

Referenced by generate_starpu_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

add_shutdown_pragma_to_return()

bool add_shutdown_pragma_to_return

(

statement

s

)

Definition at line 167 of file starpu_pragma_generation.c.

                                                {
  if(return_statement_p(s)) {
    add_pragma_str_to_statement(s,"starpu shutdown",true);
  }
  return true;
}

References add_pragma_str_to_statement(), and return_statement_p().

Referenced by generate_starpu_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

address_of_entity_p()

bool address_of_entity_p	(	call	c,
		struct context_address_of_entity *	context
	)

Definition at line 84 of file starpu_pragma_generation.c.

                                                                            {
  if(ENTITY_ADDRESS_OF_P(call_function(c))) {
    expression arg = EXPRESSION(CAR(call_arguments(c)));
    if(expression_to_entity(arg)==context->e) {
      context->found=true;
    }
  }
  return !context->found;
}

References call_arguments, call_function, CAR, ENTITY_ADDRESS_OF_P, EXPRESSION, and expression_to_entity().

Referenced by address_of_variable_is_taken().

Here is the call graph for this function:

Here is the caller graph for this function:

address_of_variable_is_taken()

static bool address_of_variable_is_taken ( void *  start, entity  e  )

static

Definition at line 94 of file starpu_pragma_generation.c.

                                                                {
  struct context_address_of_entity c = { false, e };
  gen_context_recurse(start, &c, call_domain, address_of_entity_p, gen_null2);
  return c.found;
}

References address_of_entity_p(), call_domain, context_address_of_entity::e, context_address_of_entity::found, gen_context_recurse, gen_null2(), and start.

Referenced by add_pragma_to_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

array_bounded_p()

bool array_bounded_p

(

entity

e

)

Definition at line 152 of file starpu_pragma_generation.c.

                               {
  type array_t = ultimate_type(entity_type(e));
  if(array_type_p(array_t)) {
    variable v = type_variable(array_t);
    FOREACH(dimension,d,variable_dimensions(v)) {
      if(unbounded_dimension_p(d)) {
        return false;
      }
    }
    return true;
  }
  return false;
}

References array_type_p(), context_address_of_entity::e, entity_type, FOREACH, type_variable, ultimate_type(), unbounded_dimension_p(), and variable_dimensions.

Referenced by generate_starpu_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_starpu_pragma()

bool generate_starpu_pragma

(

char *

module_name

)

regions

Initialize set for each statement

Definition at line 174 of file starpu_pragma_generation.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("GENERATE_STARPU_PRAGMA_DEBUG_LEVEL");
 
 
  /* regions */
//  set_proper_rw_effects((statement_effects) db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_proper_rw_effects((statement_effects) db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects) db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                                                      module_name,
                                                                      true));
 
 
  /* Initialize set for each statement */
  gen_recurse(module_stat, sequence_domain, add_pragma_to_sequence, gen_null);
 
 
 
  // If module is main, then register global variables
  if(entity_main_module_p(get_current_module_entity())) {
    list regs = load_cumulated_rw_effects_list(module_stat);
    ifdebug(2) {
      pips_debug(2,"Regions for main module : ");
      print_regions(regs);
    }
    // Do not use regions currently because of anywhere effects !
 //   FOREACH(effect, reg, regs) {
 //     entity e = region_entity(reg);
    list entities = gen_filter_tabulated(gen_true, entity_domain);
    FOREACH(entity, e, entities ) {
      pips_debug(6,"Considering entity %s\n",entity_name(e));
      if(top_level_entity_p(e)
          && array_bounded_p(e)) {
        pips_debug(2,"Registering global array %s in main\n",entity_user_name(e));
        statement pragma = get_statement_pragma_register(e,false);
        insert_statement(module_stat,pragma,true);
      }
    }
    insert_statement(module_stat,get_statement_pragma_init(),true);
    insert_statement(module_stat,get_statement_pragma_shutdown(),false);
    gen_recurse(module_stat, statement_domain, add_shutdown_pragma_to_return, gen_null);
  }
 
 
  module_reorder(get_current_module_statement());
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,
      module_name,
      module_stat);
 
  // We may have outline some code, so recompute the callees:
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
       compute_callees(get_current_module_statement()));
 
 
  debug_off();
 
  reset_proper_rw_effects();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_cumulated_rw_effects();
 
  return true;
}

References add_pragma_to_sequence(), add_shutdown_pragma_to_return(), array_bounded_p(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, context_address_of_entity::e, entity_domain, entity_main_module_p(), entity_name, entity_user_name(), FOREACH, gen_filter_tabulated(), gen_null(), gen_recurse, gen_true(), get_current_module_entity(), get_current_module_statement(), get_statement_pragma_init(), get_statement_pragma_register(), get_statement_pragma_shutdown(), ifdebug, insert_statement(), load_cumulated_rw_effects_list(), local_name_to_top_level_entity(), module_name(), module_reorder(), pips_debug, print_regions(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), sequence_domain, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), statement_domain, and top_level_entity_p().

Here is the call graph for this function:

get_statement_pragma_init()

static statement get_statement_pragma_init ( )

static

Definition at line 68 of file starpu_pragma_generation.c.

                                             {
  statement pragma = make_plain_continue_statement();
  add_pragma_str_to_statement(pragma,"starpu initialize",true);
  return pragma;
}

References add_pragma_str_to_statement(), and make_plain_continue_statement().

Referenced by generate_starpu_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

get_statement_pragma_register()

static statement get_statement_pragma_register ( entity  e, bool  address_of  )

static

Definition at line 56 of file starpu_pragma_generation.c.

                                                                          {
  statement pragma = make_plain_continue_statement();
  string str;
  if(address_of)
    asprintf(&str,"starpu register &%s sizeof(%s)",entity_user_name(e),entity_user_name(e));
  else
    asprintf(&str,"starpu register %s",entity_user_name(e));
 
  add_pragma_str_to_statement(pragma,str,false);
  return pragma;
}

References add_pragma_str_to_statement(), asprintf, entity_user_name(), and make_plain_continue_statement().

Referenced by add_pragma_to_sequence(), and generate_starpu_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

get_statement_pragma_shutdown()

static statement get_statement_pragma_shutdown ( )

static

Definition at line 73 of file starpu_pragma_generation.c.

                                                 {
  statement pragma = make_plain_continue_statement();
  add_pragma_str_to_statement(pragma,"starpu shutdown",true);
  return pragma;
}

References add_pragma_str_to_statement(), and make_plain_continue_statement().

Referenced by generate_starpu_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

scalar_to_array()

static void scalar_to_array ( reference  r, entity  e  )

static

Definition at line 100 of file starpu_pragma_generation.c.

                                                   {
  if(reference_variable(r)==e) {
    pips_assert("no index for scalar",ENDP(reference_indices(r)));
    expression zero = entity_to_expression(make_integer_constant_entity(0));
    reference_indices(r) = CONS(expression,zero,NIL);
  }
}

References CONS, context_address_of_entity::e, ENDP, entity_to_expression(), make_integer_constant_entity(), NIL, pips_assert, reference_indices, and reference_variable.

Referenced by add_pragma_to_sequence().

Here is the call graph for this function:

Here is the caller graph for this function: