scalopify.c

Go to the documentation of this file.

/* A simple phase that change wrap references to flow outside kernel for dataflow runtime manager
 
   clement.marguet@hpc-project.com
*/
#ifdef HAVE_CONFIG_H
#include "pips_config.h"
#endif
 
 
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "prettyprint.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 "properties.h"
#include "accel-util.h"
#include "resources.h"
 
 
 
static bool call_load_store_p(call c){
  if(strstr(entity_name(call_function(c)),get_string_property("KERNEL_LOAD_STORE_LOAD_FUNCTION"))!=NULL
     || strstr(entity_name(call_function(c)),get_string_property("KERNEL_LOAD_STORE_STORE_FUNCTION"))!=NULL){
    return true;
  }
 
  return false;
 
}
 
static bool find_call_to_wrap(call c,list *call_to_wrap){
  *call_to_wrap = CONS(CALL,c,*call_to_wrap);
  return false;
}
 
 
static bool find_entities_to_wrap(call c,set* entities_to_wrap){
 
  if(call_load_store_p(c)){
    expression exp = EXPRESSION(CAR(call_arguments(c)));
 
    if(expression_call_p(exp)){
      call expcall = expression_call(exp);
      if(call_intrinsic_p(expcall)){
        c = expcall;
      }
    }
 
    print_expression(exp);
    pips_debug(1,"=========================\n");
 
    entity e = expression_variable(EXPRESSION(CAR(call_arguments(c))));
 
    if(!set_belong_p(*entities_to_wrap,e)) {
        set_add_element(*entities_to_wrap,*entities_to_wrap,e);
    }
  }
  return true;
}
 
 
static bool pointer_to_array_p(entity e){
 
  list ls = variable_dimensions(type_variable(entity_type(e)));
 
  if(ENDP(ls)) return true;
 
  return false;
}
 
static type convert_local_to_pointer_array(type local_type){
 
  list ls        = variable_dimensions(type_variable(local_type));
  size_t size    = gen_length(ls);
  type pointer_type = make_type_variable(make_variable(copy_basic(variable_basic(type_variable(local_type))),NIL,NIL));
  basic b;
 
  for(unsigned int i = 0; i<size; i++){
    b = make_basic_pointer(pointer_type);
    pointer_type = make_type_variable(make_variable(b,NIL,NIL));
  }
 
  return pointer_type;
}
 
bool scalopify (char* module_name) {
 
  // Use this module name and this environment variable to set
  statement module_statement = PIPS_PHASE_PRELUDE(module_name,
                                                  "SCALOPIFY_DEBUG_LEVEL");
  set entities_to_wrap=set_make(set_pointer);
  list call_to_wrap=NIL;
 
  expression exp;
  type t;
 
  entity get_call_entity = local_name_to_top_level_entity("P4A_scmp_flow");
 
  set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
 
  gen_context_recurse(module_statement,&entities_to_wrap,
    call_domain, find_entities_to_wrap, gen_null2);
 
  gen_context_recurse(module_statement, &call_to_wrap,
    call_domain, find_call_to_wrap, gen_null2);
 
  FOREACH(CALL, c , call_to_wrap){
 
    if(!call_load_store_p(c)){
 
      SET_FOREACH(entity, e, entities_to_wrap){
 
        /*Two cases: vector or scalar*/
        if(entity_array_p(e)) { 
 
         exp =  MakeUnaryCall(get_call_entity, entity_to_expression(e));
 
          if(!pointer_to_array_p(e)){
            t = convert_local_to_pointer_array(entity_type(e));
          }
          else{
            t= entity_type(e);
          }
 
          exp = make_expression( make_syntax_cast(make_cast(t,exp)) ,normalized_undefined);
        }
        else{
 
          basic b   = make_basic_pointer(copy_type(entity_type(e)));
          t   = make_type_variable(make_variable(b,NIL,NIL));
 
          exp = MakeUnaryCall(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME), entity_to_expression(e));
          exp = MakeUnaryCall(get_call_entity, exp);
          exp = make_expression(make_syntax_cast(make_cast(t, exp)),normalized_undefined);
          exp = MakeUnaryCall(entity_intrinsic(DEREFERENCING_OPERATOR_NAME), exp);
        }
        replace_entity_by_expression(c, e, exp);
      }    
    }
  }
 
 
 
  gen_free_list(call_to_wrap);
  set_free(entities_to_wrap);
 
  // We may have outline some code, so recompute the callees:
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
                         compute_callees(get_current_module_statement()));
 
  reset_cumulated_rw_effects();
  // Put back the new statement module
  PIPS_PHASE_POSTLUDE(module_statement);
 
  return true;
}