ikernels.c File Reference

kernels manipulation 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 "workspace-util.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 ikernels.c:

Go to the source code of this file.

Macros
#define	INIT_STATEMENT_SIZE   20
#define	INIT_ENTITY_SIZE   10
#define	MAKE_SET()   (set_make( set_pointer ))
	Macro to create set. More...
#define	COPY_FROM_IN(st)   ((set)hash_get(copies_from_in, (char *)st))
#define	COPY_FROM_OUT(st)   ((set)hash_get(copies_from_out, (char *)st))
#define	COPY_TO_IN(st)   ((set)hash_get(copies_to_in, (char *)st))
#define	COPY_TO_OUT(st)   ((set)hash_get(copies_to_out, (char *)st))
#define	TABLE_FREE(t)    {HASH_MAP( k, v, {set_free( (set)v ) ;}, t ) ; hash_table_free(t);}

Functions
static expression	makeTransfertSizeExpression (entity e)
	Make a sizeof expression. More...
static const char *	get_dma_name (enum region_to_dma_switch m, int d)
	converts a region_to_dma_switch to corresponding dma name according to properties More...
static statement	make_dma_transfert (entity e, enum region_to_dma_switch dma)
void	dump_entity_set (set s)
	ikernels.c More...
static bool	force_renormalize (expression e)
	Should be useful, but for some bullshit reason the array dimensions even for simple case like a[512][512] might be previously normalized "COMPLEX" This occurs in some special cases... More...
static void	force_renormalize_rwt (expression e)
static bool	array_must_fully_written_by_regions_p (entity e_used, list lreg)
	Check that an array is fully written by an exact W region in a list. More...
static set	interprocedural_mapping (string res, call c)
	Translate the interprocedural summary for a function into a set of local corresponding parameters (entity only) More...
bool	is_a_kernel (const char *func_name)
static void	init_one_statement (statement st)
static void	copy_from_statement (statement st)
static void	copy_from_block (statement st, cons *sts)
static void	copy_from_test (statement st, test t)
static void	copy_from_all_kind_of_loop (statement st, statement body)
static void	copy_from_loop (statement st, loop l)
static void	copy_from_whileloop (statement st, whileloop l)
static void	copy_from_forloop (statement st, forloop l)
static void	copy_from_call (statement st, call c)
static void	copy_from_unstructured (_UNUSED_ statement st, _UNUSED_ unstructured u)
static void	copy_to_statement (statement st)
static void	copy_to_block (statement st, list sts)
static void	copy_to_test (statement st, test t)
static void	copy_to_all_kind_of_loop (statement st, statement body)
static void	copy_to_loop (statement st, loop l)
static void	copy_to_whileloop (statement st, whileloop l)
static void	copy_to_forloop (statement st, forloop l)
static void	copy_to_call (statement st, call c)
static void	copy_to_unstructured (_UNUSED_ statement st, _UNUSED_ unstructured u)
static void	get_written_entities (statement s, set written_entities)
static void	transfert_statement (statement st, set already_transfered_to, set already_transfered_from, set array_to_transfer_to_after, set array_to_transfer_from_before)
static void	transfert_block (_UNUSED_ statement st, list sts, set already_transfered, set already_transfered_from)
static void	transfert_test (_UNUSED_ statement st, test t, set already_transfered, set already_transfered_from, set transfert_to, set transfert_from)
static void	transfert_loop (_UNUSED_ statement st, loop l, set already_transfered, set already_transfered_from, set transfert_to, set transfert_from)
static void	transfert_whileloop (_UNUSED_ statement st, whileloop l, set already_transfered, set already_transfered_from, set transfert_to, set transfert_from)
static void	transfert_forloop (_UNUSED_ statement st, forloop l, set already_transfered, set already_transfered_from, set transfert_to, set transfert_from)
static void	transfert_call (_UNUSED_ statement st, _UNUSED_ call c, _UNUSED_ set already_transfered, _UNUSED_ set already_transfered_from)
static void	transfert_unstructured (_UNUSED_ statement st, _UNUSED_ unstructured u, _UNUSED_ set already_transfered, _UNUSED_ set already_transfered_from)
bool	ikernel_load_store (__attribute__((unused)) char *module_name)
bool	kernel_data_mapping (char *module_name)
static void	wrap_argument (syntax s)
static void	wrap_call_argument (call c, const char *module_name)
bool	wrap_kernel_argument (char *module_name)
	This pass will wrap kernel arguments in a call to a wrapper function. More...

Variables
static hash_table	copies_from_in
	copy_from_in maps each statement to the "copy from" data that are in-coming the statement More...
static hash_table	copies_from_out
	copy_from_out maps each statement to the "copy from" data that are out-going from the statement More...
static hash_table	copies_to_in
	copy_to_in maps each statement to the "copy to" data that are in-coming the statement More...
static hash_table	copies_to_out
	copy_to_out maps each statement to the "copy to" data that are out-going from the statement More...
static entity	wrapper_function = NULL

Detailed Description

kernels manipulation

Author

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

Definition in file ikernels.c.

Macro Definition Documentation

COPY_FROM_IN

#define COPY_FROM_IN

(

st

)

((set)hash_get(copies_from_in, (char *)st))

Definition at line 151 of file ikernels.c.

COPY_FROM_OUT

#define COPY_FROM_OUT

(

st

)

((set)hash_get(copies_from_out, (char *)st))

Definition at line 166 of file ikernels.c.

COPY_TO_IN

#define COPY_TO_IN

(

st

)

((set)hash_get(copies_to_in, (char *)st))

Definition at line 181 of file ikernels.c.

COPY_TO_OUT

#define COPY_TO_OUT

(

st

)

((set)hash_get(copies_to_out, (char *)st))

Definition at line 196 of file ikernels.c.

INIT_ENTITY_SIZE

#define INIT_ENTITY_SIZE   10

Definition at line 142 of file ikernels.c.

INIT_STATEMENT_SIZE

#define INIT_STATEMENT_SIZE   20

Definition at line 141 of file ikernels.c.

MAKE_SET

#define MAKE_SET

(

)

(set_make( set_pointer ))

Macro to create set.

Definition at line 145 of file ikernels.c.

TABLE_FREE

#define TABLE_FREE

(

t

)

{HASH_MAP( k, v, {set_free( (set)v ) ;}, t ) ; hash_table_free(t);}

Function Documentation

array_must_fully_written_by_regions_p()

static bool array_must_fully_written_by_regions_p ( entity  e_used, list  lreg  )

static

Check that an array is fully written by an exact W region in a list.

Definition at line 238 of file ikernels.c.

                                                                             {
  // Ugly hack :-(
  effect array = entity_whole_region(e_used,make_action_write_memory());
 
  // Force re-normalization of expression, this is a hack !
  gen_recurse(e_used, expression_domain, force_renormalize, force_renormalize_rwt);
  if(type_variable_p(entity_type(e_used))) {
    // I don't understand why the gen_recurse doesn't work, so here is the hack for the hack...
    FOREACH(dimension, d, variable_dimensions(type_variable(entity_type(e_used)))) {
      force_renormalize(dimension_upper(d));
      force_renormalize(dimension_lower(d));
    }
  }
 
  //
  Psysteme p = descriptor_convex(effect_descriptor(array));
  descriptor_convex(effect_descriptor(array)) = sc_safe_append(p,
                         sc_safe_normalize(entity_declaration_sc(e_used)));
  effect_approximation(array) = make_approximation_exact();
 
  ifdebug(6) {
    pips_debug(6,"Array region is : ");
    print_region(array);
  }
  FOREACH(effect, reg, lreg) {
    if(!descriptor_convex_p(effect_descriptor(reg))) continue;
    // Proj region over PHI to remove precondition variables
    // FIXME : Can be done by difference between the 2 bases
    list proj = base_to_list(sc_base(descriptor_convex(effect_descriptor(reg))));
    list l_phi = NIL;
    FOREACH(expression,e, reference_indices(effect_any_reference(reg))) {
      pips_assert("expression_reference_p", expression_reference_p(e));
      l_phi = CONS(entity,reference_variable(expression_reference(e)),l_phi);
      gen_remove(&proj,reference_variable(expression_reference(e)));
    }
 
 
    region_exact_projection_along_variables(reg, proj);
 
 
    ifdebug(6) {
      pips_debug(6,"Evaluating region : ");
      print_region(reg);
    }
    if(effect_write_p(reg) && store_effect_p(reg) && region_exact_p(reg)) {
      list ldiff = region_sup_difference(array,reg);
      bool empty=true;
      FOREACH(effect, diff, ldiff) {
        if( !region_empty_p(diff)) {
          ifdebug(6) {
            pips_debug(6,"Diff is not empty :");
            print_region(diff);
          }
          empty = false;
          break;
        } else {
          ifdebug(6) {
            pips_debug(6,"Diff is empty !\n");
          }
        }
      }
      if(empty) {
        return true;
      }
    }
  }
  return false;
}

References array, base_to_list(), CONS, descriptor_convex, descriptor_convex_p, dimension_lower, dimension_upper, effect_any_reference, effect_approximation, effect_descriptor, effect_write_p, empty, entity_declaration_sc(), entity_type, entity_whole_region(), expression_domain, expression_reference(), expression_reference_p(), force_renormalize(), force_renormalize_rwt(), FOREACH, gen_recurse, gen_remove(), ifdebug, make_action_write_memory(), make_approximation_exact(), NIL, pips_assert, pips_debug, print_region, reference_indices, reference_variable, region_empty_p, region_exact_p, region_exact_projection_along_variables(), region_sup_difference(), sc_safe_append(), sc_safe_normalize(), store_effect_p(), type_variable, type_variable_p, and variable_dimensions.

Referenced by copy_to_call().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_all_kind_of_loop()

static void copy_from_all_kind_of_loop ( statement  st, statement  body  )

static

Compute "in" sets for the loop body

Compute loop body

Fix point

Compute "out" sets for the loop

Body is always done at least one time

Body is not always done

Definition at line 448 of file ikernels.c.

                                                                     {
  /* Compute "in" sets for the loop body */
  set_assign(COPY_FROM_IN( body ), COPY_FROM_IN( st ));
 
  /* Compute loop body */
  copy_from_statement(body);
 
  /* Fix point  */
  /*
  if(!set_equal_p(COPY_FROM_IN( body ),set_intersection(COPY_FROM_IN( st ),
                                                        COPY_FROM_OUT( body ),
                                                        COPY_FROM_IN( st )))) {
    return copy_from_all_kind_of_loop(st,body);
  }
  */
 
  /* Compute "out" sets for the loop */
  if(true) { //loop_executed_once_p(st, l)) { FIXME !!!!
    pips_debug(1,"Loop executed once !\n");
    /* Body is always done at least one time */
    set_assign(COPY_FROM_OUT( st ), COPY_FROM_OUT( body ));
  } else {
    pips_debug(1,"Loop not executed once :-( !\n");
    /* Body is not always done */
    set_intersection(COPY_FROM_OUT( st ),
                     COPY_FROM_OUT( body ),
                     COPY_FROM_IN( st ));
  }
 
}

References COPY_FROM_IN, COPY_FROM_OUT, copy_from_statement(), pips_debug, set_assign(), and set_intersection().

Referenced by copy_from_forloop(), copy_from_loop(), and copy_from_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_block()

static void copy_from_block ( statement  st, cons *  sts  )

static

The initial in for the block

loop over statements inside the block

propagate "in" sets

Compute the "copy from" for this statement

Get the ins for next statement

The outs for the whole block

Definition at line 392 of file ikernels.c.

                                                     {
  /* The initial in for the block */
  set copy_from_in = COPY_FROM_IN( st );
  /* loop over statements inside the block */
  FOREACH( statement, one, sts ) {
    /* propagate "in" sets */
    set_assign(COPY_FROM_IN( one ), copy_from_in);
 
    /* Compute the "copy from" for this statement */
    copy_from_statement(one);
 
    /* Get the ins for next statement */
    copy_from_in = COPY_FROM_OUT( one );
  }
 
  /* The outs for the whole block */
  set_assign(COPY_FROM_OUT( st ), copy_from_in);
 
}

References COPY_FROM_IN, COPY_FROM_OUT, copy_from_statement(), FOREACH, and set_assign().

Referenced by copy_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_call()

static void copy_from_call ( statement  st, call  c  )

static

The initial in

The outs is initially the in

Definition at line 512 of file ikernels.c.

                                                 {
  entity callee = call_function(c);
  const char* func_name = entity_local_name(callee);
 
  /* The initial in */
  set copy_from_in = COPY_FROM_IN( st );
  set copy_from_out = COPY_FROM_OUT( st );
 
  /* The outs is initially the in */
  set_assign(copy_from_out, copy_from_in);
  if(is_a_kernel(func_name)) {
    pips_debug(3,"%s is a Kernel !\n",
        func_name);
    // it's a kernel call !!
    // Let's add the "region out" to copy_from set !
    list l_out = load_statement_out_regions(st);
    FOREACH(EFFECT, eff, l_out )
    {
      entity e_used = reference_variable(effect_any_reference(eff));
      if(entity_array_p(e_used)) {
        copy_from_out = set_add_element(copy_from_out, copy_from_out, e_used);
      }
    }
  } else {
    // Standard call (not a kernel)
    pips_debug(3,"%s is a simple call\n",
        func_name);
 
 
    // We get the inter-procedural results for copy in
    set at_call_site;
    if(user_call_p(c)) { // Ignoring intrinsics
      at_call_site = interprocedural_mapping(DBR_KERNEL_COPY_IN,c);
    } else
      at_call_site = set_make(set_pointer);
 
    // We remove from "copy from" what is used by this statement but not what's
    // in copy-in
    FOREACH(EFFECT, eff, load_proper_rw_effects_list(st) ) {
      entity e_used = reference_variable(effect_any_reference(eff));
      if(entity_array_p(e_used) && !set_belong_p(at_call_site,e_used)) {
        pips_debug(6,"Removing %s from copy_out\n",entity_name(e_used));
        copy_from_out = set_del_element(copy_from_out, copy_from_out, e_used);
      }
    }
 
    // No longer used
    set_free(at_call_site);
 
    // We add the inter-procedural results for copy out, but not for intrinsics
    if(user_call_p(c)) { // Ignoring intrinsics
      at_call_site = interprocedural_mapping(DBR_KERNEL_COPY_OUT,c);
      copy_from_out = set_union(copy_from_out, at_call_site, copy_from_out);
      ifdebug(6) {
        pips_debug(6,"Adding interprocedural summary : ");
        print_entities(set_to_list(at_call_site));
        fprintf(stderr,"\n");
      }
      set_free(at_call_site);
    }
  }
}

References call_function, callee, COPY_FROM_IN, COPY_FROM_OUT, EFFECT, effect_any_reference, entity_array_p(), entity_local_name(), entity_name, FOREACH, fprintf(), ifdebug, interprocedural_mapping(), is_a_kernel(), load_proper_rw_effects_list(), load_statement_out_regions(), pips_debug, print_entities(), reference_variable, set_add_element(), set_assign(), set_belong_p(), set_del_element(), set_free(), set_make(), set_pointer, set_to_list(), set_union(), and user_call_p().

Referenced by copy_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_forloop()

static void copy_from_forloop ( statement  st, forloop  l  )

static

Definition at line 507 of file ikernels.c.

                                                       {
  statement body = forloop_body(l);
  copy_from_all_kind_of_loop(st, body);
}

References copy_from_all_kind_of_loop(), and forloop_body.

Referenced by copy_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_loop()

static void copy_from_loop ( statement  st, loop  l  )

static

Definition at line 479 of file ikernels.c.

                                                 {
  statement body = loop_body(l);
  copy_from_all_kind_of_loop(st, body);
 
  /*
   * For further "already_transfered" optimization to be correct !
   * We have to force to transfert from the accelerator in the body of the loop
   * if we can't know that the data won't be used on the CPU at the begin of the
   * next iteration
   * see validation/Gpu/Comm_optimization.sub/loop01.c
   */
  set to_delete = MAKE_SET();
  SET_FOREACH(entity,e,COPY_FROM_OUT(st)) {
    if(!set_belong_p(COPY_TO_IN(st),e)) {
      //insert_statement(body,make_dma_transfert(e,dma_store),false);
      pips_debug(1,"Removing %s from loop copy-out !\n",entity_name(e));
      set_add_element(to_delete,to_delete,e);
    }
  }
  set_difference(COPY_FROM_OUT(st),COPY_FROM_OUT(st),to_delete);
  set_difference(COPY_FROM_OUT(body),COPY_FROM_OUT(body),to_delete);
  set_free(to_delete);
 
}

References copy_from_all_kind_of_loop(), COPY_FROM_OUT, COPY_TO_IN, entity_name, loop_body, MAKE_SET, pips_debug, set_add_element(), set_belong_p(), set_difference(), SET_FOREACH, and set_free().

Referenced by copy_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_statement()

static void copy_from_statement ( statement  st )

static

Compute "copy from" sets for the instruction : recursion

Definition at line 580 of file ikernels.c.

                                              {
  instruction i;
 
  /* Compute "copy from" sets for the instruction : recursion */
  switch(instruction_tag( i = statement_instruction( st ))) {
    case is_instruction_block:
      copy_from_block(st, instruction_block( i ));
      break;
    case is_instruction_test:
      copy_from_test(st, instruction_test( i ));
      break;
    case is_instruction_loop:
      copy_from_loop(st, instruction_loop( i ));
      break;
    case is_instruction_whileloop:
      copy_from_whileloop(st, instruction_whileloop( i ));
      break;
    case is_instruction_forloop:
      copy_from_forloop(st, instruction_forloop( i ));
      break;
    case is_instruction_call:
      copy_from_call(st, instruction_call( i ));
      break;
    case is_instruction_expression: {
      expression e = instruction_expression( i );
      if(expression_call_p(e)) {
        copy_from_call(st, expression_call(e));
      } else {
        pips_user_warning("Unsupported stmt expression : ");
        print_expression(e);
        fprintf(stderr,"\n");
        // Just propagate then...
        set copy_from_in = COPY_FROM_IN( st );
        set copy_from_out = COPY_FROM_OUT( st );
        set_assign(copy_from_out, copy_from_in);
      }
      break;
    }
    case is_instruction_goto:
      pips_internal_error("Unexpected tag %d\n", i);
      break;
    case is_instruction_unstructured:
      copy_from_unstructured(st, instruction_unstructured( i ));
      break;
    default:
      pips_internal_error("Unknown tag %d\n", instruction_tag(i) );
  }
 
  ifdebug(4) {
    fprintf(stderr,
            "** stmt (%d) associated copy from : **\n",
            (int)statement_ordering(st));
    fprintf(stderr, "*\n* OUT : ");
    {
      string str = concatenate("Copy from out : ", NULL);
      list t_from = set_to_sorted_list(COPY_FROM_OUT(st),(gen_cmp_func_t)compare_entities);
      FOREACH(entity, e, t_from) {
        fprintf(stderr, "%s ", entity_name(e));
        str = concatenate(str, " ", entity_local_name(e), NULL);
      }
      str = concatenate(str, "\n", NULL);
      if(!statement_block_p(st) || ! empty_statement_or_continue_without_comment_p(st) )
        insert_comments_to_statement(st, strdup(str));
    }
    fprintf(stderr, "*\n**********************************\n");
 
    fprintf(stderr, "* IN  : ");
    {
      string str = concatenate("Copy from in : ", NULL);
      list t_from = set_to_sorted_list(COPY_FROM_IN(st),(gen_cmp_func_t)compare_entities);
      FOREACH(entity, e, t_from) {
        fprintf(stderr, "%s ", entity_name(e));
        str = concatenate(str, " ", entity_local_name(e), NULL);
      }
      str = concatenate(str, "\n", NULL);
      if(!statement_block_p(st) || ! empty_statement_or_continue_without_comment_p(st) )
        insert_comments_to_statement(st, strdup(str));
    }
    fprintf(stderr, "*\n**********************************\n");
  }
 
}

References compare_entities(), concatenate(), copy_from_block(), copy_from_call(), copy_from_forloop(), COPY_FROM_IN, copy_from_loop(), COPY_FROM_OUT, copy_from_test(), copy_from_unstructured(), copy_from_whileloop(), empty_statement_or_continue_without_comment_p(), entity_local_name(), entity_name, expression_call(), expression_call_p(), FOREACH, fprintf(), ifdebug, insert_comments_to_statement(), instruction_block, instruction_call, instruction_expression, instruction_forloop, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_block, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, pips_internal_error, pips_user_warning, print_expression(), set_assign(), set_to_sorted_list(), statement_block_p, statement_instruction, statement_ordering, and strdup().

Referenced by copy_from_all_kind_of_loop(), copy_from_block(), copy_from_test(), and kernel_data_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_test()

static void copy_from_test ( statement  st, test  t  )

static

Compute true branch

Compute false branch

Compute "out" sets for the test

Definition at line 411 of file ikernels.c.

                                                 {
  /* Compute true branch */
  set_assign(COPY_FROM_IN( test_true(t) ), COPY_FROM_IN( st ));
  copy_from_statement(test_true(t));
 
  /* Compute false branch */
  set_assign(COPY_FROM_IN( test_false(t) ), COPY_FROM_IN( st ));
  copy_from_statement(test_false(t));
 
 
  /* Compute "out" sets for the test */
  set copy_from_out = COPY_FROM_OUT( st );
 
  set_intersection(copy_from_out, COPY_FROM_OUT( test_true(t)), COPY_FROM_OUT( test_false(t)));
 
 
  ifdebug(6) {
    pips_debug(6,"Handling copy from for test expression : ");
    print_expression(test_condition(t));
    fprintf(stderr,"\n");
    pips_debug(6,"Copy from is : ");
    print_entities(set_to_list(copy_from_out));
    fprintf(stderr,"\n");
  }
 
  // We remove from "copy from" what is used by this statement
  FOREACH(EFFECT, eff, load_proper_rw_effects_list(st) ) {
    entity e_used = reference_variable(effect_any_reference(eff));
    if(entity_array_p(e_used)) {
      pips_debug(6,"Removing %s from copy_out\n",entity_name(e_used));
      set_del_element(copy_from_out, copy_from_out, e_used);
    }
  }
 
 
}

References COPY_FROM_IN, COPY_FROM_OUT, copy_from_statement(), EFFECT, effect_any_reference, entity_array_p(), entity_name, FOREACH, fprintf(), ifdebug, load_proper_rw_effects_list(), pips_debug, print_entities(), print_expression(), reference_variable, set_assign(), set_del_element(), set_intersection(), set_to_list(), test_condition, test_false, and test_true.

Referenced by copy_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from_unstructured()

static void copy_from_unstructured ( _UNUSED_ statement  st, _UNUSED_ unstructured  u  )

static

Definition at line 575 of file ikernels.c.

                                                                                   {
  //pips_user_warning("Unimplemented !! Results may be wrong...\n");
  pips_user_error("Please restructure your input source code.\n");
}

References pips_user_error.

Referenced by copy_from_statement().

Here is the caller graph for this function:

copy_from_whileloop()

static void copy_from_whileloop ( statement  st, whileloop  l  )

static

Definition at line 503 of file ikernels.c.

                                                           {
  statement body = whileloop_body(l);
  copy_from_all_kind_of_loop(st, body);
}

References copy_from_all_kind_of_loop(), and whileloop_body.

Referenced by copy_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_all_kind_of_loop()

static void copy_to_all_kind_of_loop ( statement  st, statement  body  )

static

Compute "out" sets for the loop body

Save result

Compute loop body

Fix point

Compute "in" sets for the loop

Body is always done at least one time

Body is not always done

Definition at line 728 of file ikernels.c.

                                                                   {
  /* Compute "out" sets for the loop body */
  set body_out = COPY_TO_OUT(body);
  set_union(body_out,
            COPY_TO_OUT( st ),
            COPY_TO_IN( body ));
 
  /* Save result */
  set tmp = MAKE_SET();
  set_assign(tmp,body_out);
 
  /* Compute loop body */
  copy_to_statement(body);
 
  /* Fix point  */
  set_union(body_out ,
            COPY_TO_OUT( st ),
            COPY_TO_IN( body ));
  if(!set_equal_p(tmp,body_out)) {
    set_free(tmp);
    return copy_to_all_kind_of_loop(st,body);
  }
  set_free(tmp);
 
 
  /* Compute "in" sets for the loop */
  if(true) { //loop_executed_once_p(st, l)) {
    pips_debug(1,"Loop executed once !\n");
    /* Body is always done at least one time */
    set_assign(COPY_TO_IN( st ), COPY_TO_IN( body ));
  } else {
    pips_debug(1,"Loop not executed once :-( !\n");
    /* Body is not always done */
    set_intersection(COPY_TO_IN( st ), COPY_TO_IN( body ), COPY_TO_OUT( st ));
  }
 
 
 
 
}

References COPY_TO_IN, COPY_TO_OUT, copy_to_statement(), MAKE_SET, pips_debug, set_assign(), set_equal_p(), set_free(), set_intersection(), and set_union().

Referenced by copy_to_forloop(), copy_to_loop(), and copy_to_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_block()

static void copy_to_block ( statement  st, list  sts  )

static

The initial out for the block

loop over statements inside the block

propagate "out" sets

Compute the "copy to" for this statement

Get the outs for next statement

This is a non necessary optimisation, the set is just smaller with

The outs for the whole block

FIXME : free sts_reverse list && copy_to_out

Definition at line 669 of file ikernels.c.

                                                  {
  /* The initial out for the block */
  set copy_to_out = MAKE_SET();
  set_assign(copy_to_out, COPY_TO_OUT( st ));
  list sts_reverse = gen_nreverse(gen_copy_seq(sts));
  /* loop over statements inside the block */
  FOREACH( statement, one, sts_reverse ) {
    /* propagate "out" sets */
    set_assign(COPY_TO_OUT( one ), copy_to_out);
 
    /* Compute the "copy to" for this statement */
    copy_to_statement(one);
 
    /* Get the outs for next statement */
    set_assign(copy_to_out, COPY_TO_IN( one ));
 
    /* This is a non necessary optimisation, the set is just smaller with */
//    set_difference(copy_to_out, copy_to_out, COPY_FROM_IN(one));
  }
 
  /* The outs for the whole block */
  set_assign(COPY_TO_IN( st ), copy_to_out);
 
  /* FIXME : free sts_reverse list && copy_to_out*/
 
}

References COPY_TO_IN, COPY_TO_OUT, copy_to_statement(), FOREACH, gen_copy_seq(), gen_nreverse(), MAKE_SET, and set_assign().

Referenced by copy_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_call()

static void copy_to_call ( statement  st, call  c  )

static

The initial

The ins are initially the out minus CopyFrom

Definition at line 780 of file ikernels.c.

                                               {
  entity callee = call_function(c);
  const char* func_name = entity_local_name(callee);
 
  /* The initial */
  set copy_to_in = COPY_TO_IN( st );
  set copy_to_out = COPY_TO_OUT( st );
 
  /* The ins are initially the out minus CopyFrom*/
  set_assign(copy_to_in, copy_to_out);
  if(is_a_kernel(func_name)) {
    pips_debug(3,"%s is a Kernel !\n",
        func_name);
    // it's a kernel call !!
    // Let's add the "region in" and "region out" to copy_to set !
    list l_in = load_statement_in_regions(st);
    FOREACH(EFFECT, eff, l_in )
    {
      entity e_used = reference_variable(effect_any_reference(eff));
      if(entity_array_p(e_used)) {
        pips_debug(6,"Adding in %s into copy_in\n",entity_name(e_used));
        copy_to_in = set_add_element(copy_to_in, copy_to_in, e_used);
      }
    }
    list l_out = load_statement_out_regions(st);
    FOREACH(EFFECT, eff, l_out )
    {
      entity e_used = reference_variable(effect_any_reference(eff));
      if(entity_array_p(e_used)) {
        list lreg = load_proper_rw_effects_list(st);
 
        if(!array_must_fully_written_by_regions_p(e_used,lreg)) {
          pips_debug(6,"Adding written %s into copy_in\n",entity_name(e_used));
          copy_to_in = set_add_element(copy_to_in, copy_to_in, e_used);
        } else {
          pips_debug(6,"Do not add %s into copy_in because fully overwritten\n",
                     entity_name(e_used));
        }
      }
    }
  } else {
    // Standard call (not a kernel)
    pips_debug(3,"%s is a simple call\n",
        func_name);
    // We remove from "copy to" what is written by this statement
    FOREACH(EFFECT, eff, load_proper_rw_effects_list(st) ) {
//      if(effect_write_p(eff)) { BUGGY at that time ! it breaks hoisting transfers out of loop... the scheme is broken by design !
        entity e_used = reference_variable(effect_any_reference(eff));
        ifdebug(6) {
          if(entity_array_p(e_used)) {
            pips_debug(6,"Removing %s from copy_in\n",entity_name(e_used));
          }
        }
        copy_to_in = set_del_element(copy_to_in, copy_to_in, e_used);
//      }
    }
 
 
    // We add the inter-procedural results for copy in, but not for intrinsics
    if(user_call_p(c)) { // Ignoring intrinsics
      set at_call_site = interprocedural_mapping(DBR_KERNEL_COPY_IN,c);
      copy_to_in = set_union(copy_to_in, at_call_site, copy_to_in);
      set_free(at_call_site);
    }
 
  }
  //  copy_to_in = set_difference(copy_to_in, copy_to_in, COPY_FROM_IN(st));
}

References array_must_fully_written_by_regions_p(), call_function, callee, COPY_TO_IN, COPY_TO_OUT, EFFECT, effect_any_reference, entity_array_p(), entity_local_name(), entity_name, FOREACH, ifdebug, interprocedural_mapping(), is_a_kernel(), load_proper_rw_effects_list(), load_statement_in_regions(), load_statement_out_regions(), pips_debug, reference_variable, set_add_element(), set_assign(), set_del_element(), set_free(), set_union(), and user_call_p().

Referenced by copy_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_forloop()

static void copy_to_forloop ( statement  st, forloop  l  )

static

Definition at line 776 of file ikernels.c.

                                                     {
  statement body = forloop_body(l);
  copy_to_all_kind_of_loop(st, body);
}

References copy_to_all_kind_of_loop(), and forloop_body.

Referenced by copy_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_loop()

static void copy_to_loop ( statement  st, loop  l  )

static

Definition at line 768 of file ikernels.c.

                                               {
  statement body = loop_body(l);
  copy_to_all_kind_of_loop(st, body);
}

References copy_to_all_kind_of_loop(), and loop_body.

Referenced by copy_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_statement()

static void copy_to_statement ( statement  st )

static

Compute "copy from" sets for the instruction : recursion

The ins are initially the out minus CopyFrom

Definition at line 863 of file ikernels.c.

                                            {
  instruction i;
 
  /* Compute "copy from" sets for the instruction : recursion */
  switch(instruction_tag( i = statement_instruction( st ))) {
    case is_instruction_block:
      copy_to_block(st, instruction_block( i ));
      break;
    case is_instruction_test:
      copy_to_test(st, instruction_test( i ));
      break;
    case is_instruction_loop:
      copy_to_loop(st, instruction_loop( i ));
      break;
    case is_instruction_whileloop:
      copy_to_whileloop(st, instruction_whileloop( i ));
      break;
    case is_instruction_forloop:
      copy_to_forloop(st, instruction_forloop( i ));
      break;
    case is_instruction_call:
      copy_to_call(st, instruction_call( i ));
      break;
    case is_instruction_expression: {
      expression e = instruction_expression( i );
      if(expression_call_p(e)) {
        copy_to_call(st, expression_call(e));
      } else {
        pips_user_warning("Unsupported stmt expression : ");
        print_expression(e);
        fprintf(stderr,"\n");
        // Just propagate then...
        set copy_to_in = COPY_TO_IN( st );
        set copy_to_out = COPY_TO_OUT( st );
        /* The ins are initially the out minus CopyFrom*/
        set_assign(copy_to_in, copy_to_out);
      }
      break;
    }
    case is_instruction_goto:
      pips_internal_error("Unexpected instruction tag %d\n", i);
      break;
    case is_instruction_unstructured:
      copy_to_unstructured(st, instruction_unstructured( i ));
      break;
    default:
      pips_internal_error("Unknown tag %d\n", instruction_tag(i) );
  }
 
 
  // We remove from "copy to out" what is not written by this statement
  set allowed_to_copy_to= MAKE_SET();
  gen_context_recurse(st, allowed_to_copy_to,
    statement_domain, gen_true2, get_written_entities);
  ifdebug(4) {
    pips_debug(4,"Removing from copy_to_out what is not written here : ");
    set removed = MAKE_SET();
    set_difference(removed,COPY_TO_OUT(st),allowed_to_copy_to);
    list t_to = set_to_sorted_list(removed,(gen_cmp_func_t)compare_entities);
    FOREACH(entity, e, t_to) {
      fprintf(stderr, "%s ", entity_name(e));
    }
    fprintf(stderr, "\n");
  }
  set_intersection(COPY_TO_OUT(st),COPY_TO_OUT(st),allowed_to_copy_to);
  set_free(allowed_to_copy_to);
 
 
  ifdebug(4) {
    fprintf(stderr,
            "** stmt (%d) associated copy to : **\n",
            (int)statement_ordering(st));
    fprintf(stderr, "*\n* OUT : ");
    {
      string str = concatenate("Copy to out : ", NULL);
      list t_to = set_to_sorted_list(COPY_TO_OUT(st),(gen_cmp_func_t)compare_entities);
      FOREACH(entity, e, t_to) {
        fprintf(stderr, "%s ", entity_name(e));
        str = concatenate(str, " ", entity_local_name(e), NULL);
      }
      str = concatenate(str, "\n", NULL);
      if(!statement_block_p(st) || ! empty_statement_or_continue_without_comment_p(st) )
        insert_comments_to_statement(st, strdup(str));
    }
    fprintf(stderr, "* IN  : ");
    {
      string str = concatenate("Copy to in : ", NULL);
      list t_to = set_to_sorted_list(COPY_TO_IN(st),(gen_cmp_func_t)compare_entities);
      FOREACH(entity, e, t_to) {
        fprintf(stderr, "%s ", entity_name(e));
        str = concatenate(str, " ", entity_local_name(e), NULL);
      }
      str = concatenate(str, "\n", NULL);
      if(!statement_block_p(st) || !empty_statement_or_continue_without_comment_p(st) )
        insert_comments_to_statement(st, strdup(str));
    }
    fprintf(stderr, "*\n**********************************\n");
  }
 
 
}

References compare_entities(), concatenate(), copy_to_block(), copy_to_call(), copy_to_forloop(), COPY_TO_IN, copy_to_loop(), COPY_TO_OUT, copy_to_test(), copy_to_unstructured(), copy_to_whileloop(), empty_statement_or_continue_without_comment_p(), entity_local_name(), entity_name, expression_call(), expression_call_p(), FOREACH, fprintf(), gen_context_recurse, gen_true2(), get_written_entities(), ifdebug, insert_comments_to_statement(), instruction_block, instruction_call, instruction_expression, instruction_forloop, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_block, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, MAKE_SET, pips_debug, pips_internal_error, pips_user_warning, print_expression(), set_assign(), set_difference(), set_free(), set_intersection(), set_to_sorted_list(), statement_block_p, statement_domain, statement_instruction, statement_ordering, and strdup().

Referenced by copy_to_all_kind_of_loop(), copy_to_block(), copy_to_test(), and kernel_data_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_test()

static void copy_to_test ( statement  st, test  t  )

static

Compute true branch

Compute false branch

Compute "in" sets for the test

Definition at line 695 of file ikernels.c.

                                               {
  /* Compute true branch */
  set_assign(COPY_TO_OUT( test_true(t) ), COPY_TO_OUT( st ));
  copy_to_statement(test_true(t));
 
  /* Compute false branch */
  set_assign(COPY_TO_OUT( test_false(t) ), COPY_TO_OUT( st ));
  copy_to_statement(test_false(t));
 
 
  /* Compute "in" sets for the test */
  set copy_to_in = COPY_TO_IN( st );
 
  set_intersection(copy_to_in, COPY_TO_IN( test_true(t)), COPY_TO_IN( test_false(t)));
 
  ifdebug(6) {
    pips_debug(6,"Handling copy to for test expression : ");
    print_expression(test_condition(t));
    fprintf(stderr,"\n");
  }
 
  // We remove from "copy to" what is used by the test condition
  FOREACH(EFFECT, eff, load_proper_rw_effects_list(st) ) {
    entity e_used = reference_variable(effect_any_reference(eff));
    if(entity_array_p(e_used)) {
      pips_debug(6,"Removing %s from copy_in\n",entity_name(e_used));
      set_del_element(copy_to_in, copy_to_in, e_used);
    }
  }
 
 
 
}

References COPY_TO_IN, COPY_TO_OUT, copy_to_statement(), EFFECT, effect_any_reference, entity_array_p(), entity_name, FOREACH, fprintf(), ifdebug, load_proper_rw_effects_list(), pips_debug, print_expression(), reference_variable, set_assign(), set_del_element(), set_intersection(), test_condition, test_false, and test_true.

Referenced by copy_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_unstructured()

static void copy_to_unstructured ( _UNUSED_ statement  st, _UNUSED_ unstructured  u  )

static

Definition at line 849 of file ikernels.c.

                                                                                 {
  //pips_user_warning("Unimplemented !! Results may be wrong...\n");
  pips_user_error("Please restructure your source code.\n");
}

References pips_user_error.

Referenced by copy_to_statement().

Here is the caller graph for this function:

copy_to_whileloop()

static void copy_to_whileloop ( statement  st, whileloop  l  )

static

Definition at line 772 of file ikernels.c.

                                                         {
  statement body = whileloop_body(l);
  copy_to_all_kind_of_loop(st, body);
}

References copy_to_all_kind_of_loop(), and whileloop_body.

Referenced by copy_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_entity_set()

void dump_entity_set

(

set

s

)

ikernels.c

Definition at line 209 of file ikernels.c.

                            {
  SET_FOREACH(entity, e, s) {
    fprintf(stderr,"%s,",entity_name(e));
  }
  fprintf(stderr,"\n");
}

References entity_name, fprintf(), and SET_FOREACH.

Here is the call graph for this function:

force_renormalize()

static bool force_renormalize ( expression  e )

static

Should be useful, but for some bullshit reason the array dimensions even for simple case like a[512][512] might be previously normalized "COMPLEX" This occurs in some special cases...

Definition at line 221 of file ikernels.c.

                                            {
  if(!normalized_undefined_p(expression_normalized(e))) {
    // Remove a warning
    free_normalized(expression_normalized(e));
    expression_normalized(e) = normalized_undefined;
  }
  expression_normalized(e) = NormalizeExpression(e);
  return true;
}

References expression_normalized, free_normalized(), normalized_undefined, normalized_undefined_p, and NormalizeExpression().

Referenced by array_must_fully_written_by_regions_p(), and force_renormalize_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

force_renormalize_rwt()

static void force_renormalize_rwt ( expression  e )

static

Definition at line 231 of file ikernels.c.

                                                {
  (void) force_renormalize(e);
}

References force_renormalize().

Referenced by array_must_fully_written_by_regions_p().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dma_name()

static const char* get_dma_name ( enum region_to_dma_switch  m, int  d  )

static

converts a region_to_dma_switch to corresponding dma name according to properties

If the DMA is not scalar, the DMA function name is in the property of the form KERNEL_LOAD_STORE_LOAD/STORE_FUNCTION_dD:

Definition at line 92 of file ikernels.c.

                                                                    {
  char *seeds[] = { "KERNEL_LOAD_STORE_LOAD_FUNCTION",
                    "KERNEL_LOAD_STORE_STORE_FUNCTION",
                    "KERNEL_LOAD_STORE_ALLOCATE_FUNCTION",
                    "KERNEL_LOAD_STORE_DEALLOCATE_FUNCTION" };
  const char * propname = seeds[(int)m];
  /* If the DMA is not scalar, the DMA function name is in the property
   of the form KERNEL_LOAD_STORE_LOAD/STORE_FUNCTION_dD: */
  char * apropname=NULL;
  if(d > 0 && (int)m < 2)
    asprintf(&apropname, "%s_%dD", seeds[(int)m], (int)d);
  const char* dmaname = get_string_property(propname);
  if(apropname)
    free(apropname);
  pips_debug(6,"Get dma name : %s\n",dmaname);
  return dmaname;
}

References asprintf, free(), get_string_property(), int, and pips_debug.

Referenced by make_dma_transfert().

Here is the call graph for this function:

Here is the caller graph for this function:

get_written_entities()

static void get_written_entities ( statement  s, set  written_entities  )

static

Definition at line 854 of file ikernels.c.

                                                                    {
  FOREACH(EFFECT, eff, load_proper_rw_effects_list(s) ) {
    if(effect_write_p(eff) && store_effect_p(eff)) {
      entity e_used = reference_variable(effect_any_reference(eff));
      set_add_element(written_entities,written_entities,e_used);
    }
  }
}

References EFFECT, effect_any_reference, effect_write_p, FOREACH, load_proper_rw_effects_list(), reference_variable, set_add_element(), and store_effect_p().

Referenced by copy_to_statement(), and transfert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

ikernel_load_store()

bool ikernel_load_store

(

__attribute__((unused)) char *

module_name

)

set_entity_to_size(); should be performed at the workspace level

out regions

in regions

preconditions

Definition at line 1301 of file ikernels.c.

                                                                    {
  statement module_stat;
 
  set_current_module_statement((statement)db_get_memory_resource(DBR_CODE,
                                                                 module_name,
                                                                 true));
  module_stat = get_current_module_statement();
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  /* set_entity_to_size(); should be performed at the workspace level */
 
  debug_on("KERNEL_DATA_MAPPING_DEBUG_LEVEL");
 
  string pe = db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true);
  set_proper_rw_effects((statement_effects)pe);
 
  /* out regions */
  string or = db_get_memory_resource(DBR_OUT_REGIONS, module_name, true);
  set_out_effects((statement_effects)or);
 
  /* in regions */
  string ir = db_get_memory_resource(DBR_IN_REGIONS, module_name, true);
  set_in_effects((statement_effects)ir);
 
  /* preconditions */
  string precond = db_get_memory_resource(DBR_PRECONDITIONS, module_name, true);
  set_precondition_map((statement_mapping)precond);
 
  transfert_statement(module_stat, MAKE_SET(), MAKE_SET(), NULL, NULL);
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,
      module_name,
      module_stat);
 
  reset_proper_rw_effects();
  reset_out_effects();
  reset_in_effects();
  reset_precondition_map();
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_on, get_current_module_statement(), local_name_to_top_level_entity(), MAKE_SET, module_name(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), and transfert_statement().

Here is the call graph for this function:

init_one_statement()

static void init_one_statement ( statement  st )

static

First initialization (normal use)

If the statement has never been seen, allocate new sets:

Definition at line 379 of file ikernels.c.

                                             {
  if(COPY_FROM_IN( st ) == (set)HASH_UNDEFINED_VALUE) {
    /* First initialization (normal use) */
    /* If the statement has never been seen, allocate new sets: */
    hash_put(copies_from_in, (char *)st, (char *)MAKE_SET());
    hash_put(copies_from_out, (char *)st, (char *)MAKE_SET());
    hash_put(copies_to_in, (char *)st, (char *)MAKE_SET());
    hash_put(copies_to_out, (char *)st, (char *)MAKE_SET());
  }
}

References copies_from_in, copies_from_out, copies_to_in, copies_to_out, COPY_FROM_IN, hash_put(), HASH_UNDEFINED_VALUE, and MAKE_SET.

Referenced by kernel_data_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

interprocedural_mapping()

static set interprocedural_mapping ( string  res, call  c  )

static

Translate the interprocedural summary for a function into a set of local corresponding parameters (entity only)

of entity

if there are more actuals than formals, they are skipped.

Definition at line 311 of file ikernels.c.

                                                       {
  entity callee = call_function(c);
  const char* func_name = entity_local_name(callee);
  memory_mapping mem_map = (memory_mapping)db_get_memory_resource(res,
                                                                  func_name,
                                                                  true);
  set summary = MAKE_SET();
  set_assign(summary,memory_mapping_map(mem_map));
 
 
  list /* of entity */l_formals = module_formal_parameters(callee);
  int arg_num, n_formals = gen_length(l_formals);
  gen_free_list(l_formals);
 
  /* if there are more actuals than formals, they are skipped.
   */
  set at_call_site = MAKE_SET();
  list real_args = call_arguments(c);
  for (arg_num = 1; !ENDP(real_args) && arg_num <= n_formals; real_args
      = CDR(real_args), arg_num++) {
    entity formal_ent = find_ith_formal_parameter(callee, arg_num);
    bool found = false;
    SET_FOREACH(entity, e, summary) {
      if(same_entity_p(e, formal_ent)) {
        set_del_element(summary,summary,e);
        found = true;
        break;
      }
    }
    if(found) {
      expression real_exp = EXPRESSION(CAR(real_args));
 
      if(expression_reference_p(real_exp)) {
        reference r = syntax_reference(expression_syntax(real_exp));
        set_add_element(at_call_site, at_call_site, reference_variable(r));
      } else {
        pips_user_warning(
            "Interprocedural mapping on %s map on a non ref expression ",
            entity_name(formal_ent));
        print_syntax(expression_syntax(real_exp));
        fprintf(stderr, "\n");
      }
    }
  }
  SET_FOREACH(entity, e, summary) {
    pips_debug(4,"%s not mapped on formal\n",entity_name(e));
    if(top_level_entity_p(e)) {
      set_add_element(at_call_site,at_call_site,e);
    } else {
      pips_internal_error("Interprocedural error : entity %s is not a formal"
          " not a global variable !\n",entity_name(e));
    }
  }
  return at_call_site;
}

References call_arguments, call_function, callee, CAR, CDR, db_get_memory_resource(), ENDP, entity_local_name(), entity_name, EXPRESSION, expression_reference_p(), expression_syntax, find_ith_formal_parameter(), fprintf(), gen_free_list(), gen_length(), MAKE_SET, memory_mapping_map, module_formal_parameters(), pips_debug, pips_internal_error, pips_user_warning, print_syntax(), reference_variable, same_entity_p(), set_add_element(), set_assign(), set_del_element(), SET_FOREACH, syntax_reference, and top_level_entity_p().

Referenced by copy_from_call(), and copy_to_call().

Here is the call graph for this function:

Here is the caller graph for this function:

is_a_kernel()

bool is_a_kernel

(

const char *

func_name

)

Parameters

func_name

unc_name

Definition at line 369 of file ikernels.c.

                                        {
  callees kernels = (callees)db_get_memory_resource(DBR_KERNELS, "", true);
  bool found = false;
  FOREACH(STRING,kernel_name,callees_callees(kernels)) {
    if((found = (same_string_p(kernel_name,func_name))))
      break;
  }
  return found;
}

References callees_callees, db_get_memory_resource(), FOREACH, same_string_p, and STRING.

Referenced by copy_from_call(), copy_to_call(), kernel_data_mapping(), and opencl_compile_mergeable_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

kernel_data_mapping()

bool kernel_data_mapping

(

char *

module_name

)

set_entity_to_size(); should be performed at the workspace level

regions

out regions

in regions

preconditions

preconditions

Initialize global hashtables

Initialize set for each statement

Run the pass except if current module is a kernel

Parameters

module_name

odule_name

Definition at line 1344 of file ikernels.c.

                                             {
  statement module_stat;
 
  set_current_module_statement((statement)db_get_memory_resource(DBR_CODE,
                                                                 module_name,
                                                                 true));
  module_stat = get_current_module_statement();
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  /* set_entity_to_size(); should be performed at the workspace level */
 
  debug_on("KERNEL_DATA_MAPPING_DEBUG_LEVEL");
 
 
  /* regions */
  string region = db_get_memory_resource(DBR_REGIONS, module_name, true);
  set_proper_rw_effects((statement_effects)region);
 
 
  /* out regions */
  string or = db_get_memory_resource(DBR_OUT_REGIONS, module_name, true);
  set_out_effects((statement_effects)or);
 
  /* in regions */
  string ir = db_get_memory_resource(DBR_IN_REGIONS, module_name, true);
  set_in_effects((statement_effects)ir);
 
  /* preconditions */
  string precond = db_get_memory_resource(DBR_PRECONDITIONS, module_name, true);
  set_precondition_map((statement_mapping)precond);
 
  /* preconditions */
  string cumu = db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true);
  set_cumulated_rw_effects((statement_effects)cumu);
 
  // Stuff for ... ?
  module_to_value_mappings(get_current_module_entity());
 
 
  /* Initialize global hashtables */
  copies_from_in = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
  copies_from_out = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
  copies_to_in = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
  copies_to_out = hash_table_make(hash_pointer, INIT_STATEMENT_SIZE);
 
  /* Initialize set for each statement */
  gen_recurse(module_stat, statement_domain, gen_true, init_one_statement);
 
  /* Run the pass except if current module is a kernel */
  if(!is_a_kernel(module_name)) {
    copy_from_statement(module_stat);
    copy_to_statement(module_stat);
    // Is it a bad hack ? Should we need a fix point here ?
    copy_from_statement(module_stat);
 
    transfert_statement(module_stat, MAKE_SET(), MAKE_SET(), MAKE_SET(), MAKE_SET());
  }
 
  ifdebug(1) {
    pips_debug(1,"Interprocedural summary for %s :\n To :",module_name);
    print_entities(set_to_list(COPY_TO_IN(module_stat)));
    fprintf(stderr,"\n From :");
    print_entities(set_to_list(COPY_FROM_OUT(module_stat)));
    fprintf(stderr,"\n");
  }
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,
      module_name,
      module_stat);
 
  DB_PUT_MEMORY_RESOURCE(DBR_KERNEL_COPY_IN,
      module_name,
      make_memory_mapping(COPY_TO_IN(module_stat)));
  DB_PUT_MEMORY_RESOURCE(DBR_KERNEL_COPY_OUT,
      module_name,
      make_memory_mapping(COPY_FROM_OUT(module_stat)));
 
#define TABLE_FREE(t)             \
  {HASH_MAP( k, v, {set_free( (set)v ) ;}, t ) ; hash_table_free(t);}
 
  //  TABLE_FREE(copies_from_in);
  //  TABLE_FREE(copies_from_out);
 
  reset_proper_rw_effects();
  reset_out_effects();
  reset_in_effects();
  reset_precondition_map();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_cumulated_rw_effects();
  free_value_mappings();
 
  return true;
}

References copies_from_in, copies_from_out, copies_to_in, copies_to_out, COPY_FROM_OUT, copy_from_statement(), COPY_TO_IN, copy_to_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_on, fprintf(), free_value_mappings(), gen_recurse, gen_true(), get_current_module_entity(), get_current_module_statement(), hash_pointer, hash_table_make(), ifdebug, init_one_statement(), INIT_STATEMENT_SIZE, is_a_kernel(), local_name_to_top_level_entity(), make_memory_mapping(), MAKE_SET, module_name(), module_to_value_mappings(), pips_debug, print_entities(), region, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), set_to_list(), statement_domain, and transfert_statement().

Here is the call graph for this function:

make_dma_transfert()

static statement make_dma_transfert ( entity  e, enum region_to_dma_switch  dma  )

static

Definition at line 110 of file ikernels.c.

                                                                             {
 
  const char* function_name = get_dma_name(dma, 0);
  entity mcpy = module_name_to_entity(function_name);
  if(entity_undefined_p(mcpy)) {
    mcpy
        = make_empty_subroutine(function_name,
                                copy_language(module_language(get_current_module_entity())));
    pips_user_warning("Cannot find \"%s\" method. Are you sure you have set\n"
        "KERNEL_LOAD_STORE_..._FUNCTION "
        "to a defined entity and added the correct .c file?\n",function_name);
  } else {
    AddEntityToModuleCompilationUnit(mcpy, get_current_module_entity());
  }
  list args = NIL;
  /*
  expression entity_exp = entity_to_expression(e);
  if(entity_pointer_p(e)) {
    entity_exp = MakeUnaryCall(entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
       entity_to_expression(e));
  }
 
  expression size_of_e = MakeSizeofExpression(entity_exp);*/
  expression size_of_e = makeTransfertSizeExpression(e);
 
  args = make_expression_list(entity_to_expression(e),size_of_e);
 
  call c = make_call(mcpy, args);
  return instruction_to_statement(make_instruction_call(c));
}

References AddEntityToModuleCompilationUnit(), copy_language(), entity_to_expression(), entity_undefined_p, get_current_module_entity(), get_dma_name(), instruction_to_statement(), make_call(), make_empty_subroutine(), make_expression_list, make_instruction_call(), makeTransfertSizeExpression(), module_language, module_name_to_entity(), NIL, and pips_user_warning.

Referenced by transfert_block(), and transfert_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

makeTransfertSizeExpression()

static expression makeTransfertSizeExpression ( entity  e )

static

Make a sizeof expression.

Definition at line 63 of file ikernels.c.

                                                          {
  type array_type = entity_type(e);
  pips_assert("Must be a variable type", type_variable_p(array_type));
  variable v_type = type_variable(array_type);
 
 
  // FIXME free memory
  type element_type = make_type_variable(
            make_variable(
                copy_basic(variable_basic(v_type)),
                NIL,NIL)
            );
 
  expression transfer_size = SizeOfDimensions(variable_dimensions(v_type));
  transfer_size=MakeBinaryCall(
          entity_intrinsic(MULTIPLY_OPERATOR_NAME),
          make_expression(
              make_syntax_sizeofexpression(make_sizeofexpression_type(element_type)),
              normalized_undefined
              ),
          transfer_size);
 
  return transfer_size;
}

References copy_basic(), entity_intrinsic(), entity_type, make_expression(), make_sizeofexpression_type(), make_syntax_sizeofexpression(), make_type_variable(), make_variable(), MakeBinaryCall(), MULTIPLY_OPERATOR_NAME, NIL, normalized_undefined, pips_assert, SizeOfDimensions(), type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by make_dma_transfert(), and wrap_argument().

Here is the call graph for this function:

Here is the caller graph for this function:

transfert_block()

static void transfert_block ( _UNUSED_ statement  st, list  sts, set  already_transfered, set  already_transfered_from  )

static

loop over statements inside the block

Compute the transfer for this statement

Definition at line 975 of file ikernels.c.

                                                         {
 
  pips_debug(4,"Entering transfert_block\n");
 
  /* loop over statements inside the block */
  for (list current = (sts); !ENDP(current); POP(current)) {
    statement one = STATEMENT(CAR(current));
 
    // These are here to record what a statement require to transfer
    // We generate transfers only in sequence
    set transfert_to = MAKE_SET();
    set transfert_from = MAKE_SET();
 
    /* Compute the transfer for this statement */
    transfert_statement(one,
                        already_transfered,
                        already_transfered_from,
                        transfert_to,
                        transfert_from);
    // Really insert the transfers statement
    list t_from = set_to_sorted_list(transfert_from,(gen_cmp_func_t)compare_entities);
    FOREACH(entity, e_from, t_from) {
      statement new_st_from = make_dma_transfert(e_from, dma_store);
      CDR(current) = CONS(statement,one,CDR(current));
      CAR(current).e = new_st_from;
      POP(current);
    }
    gen_free_list(t_from);
 
 
    list t_to = set_to_sorted_list(transfert_to,(gen_cmp_func_t)compare_entities);
    FOREACH(entity, e_to, t_to) {
      statement new_st_to = make_dma_transfert(e_to, dma_load);
      CDR(current) = CONS(statement,new_st_to,CDR(current));
      POP(current);
    }
    gen_free_list(t_to);
  }
 
 
}

References CAR, CDR, compare_entities(), CONS, current, dma_load, dma_store, ENDP, FOREACH, gen_free_list(), make_dma_transfert(), MAKE_SET, pips_debug, POP, set_to_sorted_list(), STATEMENT, and transfert_statement().

Referenced by transfert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

transfert_call()

static void transfert_call ( _UNUSED_ statement  st, _UNUSED_ call  c, _UNUSED_ set  already_transfered, _UNUSED_ set  already_transfered_from  )

static

Definition at line 1138 of file ikernels.c.

                                                                 {
}

Referenced by transfert_statement().

Here is the caller graph for this function:

transfert_forloop()

static void transfert_forloop ( _UNUSED_ statement  st, forloop  l, set  already_transfered, set  already_transfered_from, set  transfert_to, set  transfert_from  )

static

Compute loop body

Definition at line 1123 of file ikernels.c.

                                                  {
  statement body = forloop_body(l);
 
  /* Compute loop body */
  transfert_statement(body,
                      already_transfered,
                      already_transfered_from,
                      transfert_to,
                      transfert_from);
}

References forloop_body, and transfert_statement().

Referenced by transfert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

transfert_loop()

static void transfert_loop ( _UNUSED_ statement  st, loop  l, set  already_transfered, set  already_transfered_from, set  transfert_to, set  transfert_from  )

static

Compute loop body

Definition at line 1059 of file ikernels.c.

                                               {
  statement body = loop_body(l);
 
  /* Compute loop body */
  transfert_statement(body,
                      already_transfered,
                      already_transfered_from,
                      transfert_to,
                      transfert_from);
 
 
  /*
   *  At the end of a loop, we check that any transfer that need to be done
   */
 
  // Retrieve the last statement of the loop body
  set last_copy_from = set_undefined;
  if (!statement_sequence_p(body)) {
    last_copy_from = COPY_FROM_OUT(body);
  } else {
    // FC: apparently last_copy_from may not be always assigned...
    FOREACH(statement, s, sequence_statements(statement_sequence(body))) {
      set copy_from = COPY_FROM_OUT(s);
      if (copy_from && !set_undefined_p(copy_from))
        last_copy_from = copy_from;
    }
  }
 
  /*
   *  Compute the set of entity that are not on the GPU at the begin of the loop
   *  but need a copy-out at the end, after the last statement
   */
  set fixed_transfert_from = MAKE_SET();
  set_difference(fixed_transfert_from,last_copy_from,COPY_FROM_OUT(body));
  list t_from = set_to_sorted_list(fixed_transfert_from,(gen_cmp_func_t)compare_entities);
  set_free(fixed_transfert_from);
  // Insert transfers at the end of the loop !
  FOREACH(entity, e_from, t_from) {
    insert_statement(body,make_dma_transfert(e_from, dma_store),false);
  }
 
 
}

References compare_entities(), COPY_FROM_OUT, dma_store, FOREACH, insert_statement(), loop_body, make_dma_transfert(), MAKE_SET, sequence_statements, set_difference(), set_free(), set_to_sorted_list(), set_undefined, set_undefined_p, statement_sequence(), statement_sequence_p(), and transfert_statement().

Referenced by transfert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

transfert_statement()

static void transfert_statement ( statement  st, set  already_transfered_to, set  already_transfered_from, set  array_to_transfer_to_after, set  array_to_transfer_from_before  )

static

Compute "copy from" sets for the instruction : recursion

The second argument is not used

Definition at line 1152 of file ikernels.c.

                                                                   {
 
  instruction i = statement_instruction( st );
 
  set transferts_to = MAKE_SET();
  set_difference(transferts_to, COPY_TO_OUT(st), COPY_TO_IN(st));
  set_difference(transferts_to, transferts_to, COPY_FROM_OUT(st));
  set_difference(transferts_to, transferts_to, already_transfered_to);
 
  // We remove from "transfers_to" what is not written by this statement
  set allowed_to_transfer_to= MAKE_SET();
  gen_context_recurse(st, allowed_to_transfer_to,
                  statement_domain, gen_true2, get_written_entities);
  ifdebug(4) {
    pips_debug(4,"Removing from transfer_to what is not written here : ");
    set removed = MAKE_SET();
    set_difference(removed,transferts_to,allowed_to_transfer_to);
    list t_to = set_to_sorted_list(removed,(gen_cmp_func_t)compare_entities);
    FOREACH(entity, e, t_to) {
      fprintf(stderr, "%s ", entity_name(e));
    }
    fprintf(stderr, "\n");
  }
  set_intersection(transferts_to,transferts_to,allowed_to_transfer_to);
  set_free(allowed_to_transfer_to);
 
 
  SET_FOREACH(entity, e, transferts_to) {
    set_add_element(already_transfered_to, already_transfered_to, e);
    set_add_element(array_to_transfer_to_after, array_to_transfer_to_after, e);
 
    ifdebug(2) {
      string str = strdup(concatenate("Transfert to accel : ",
                                      entity_local_name(e),
                                      "\n",
                                      NULL));
      pips_debug(4,"(%zd) %s",statement_number(st),concatenate("Inserting :",str,"\n",NULL));
      insert_comments_to_statement(st, str);
      free(str);
    }
  }
 
  set transferts_from = MAKE_SET();
  set_difference(transferts_from, COPY_FROM_IN(st), COPY_FROM_OUT(st));
  set_difference(transferts_from, transferts_from, COPY_TO_IN(st));
  set_difference(transferts_from, transferts_from, already_transfered_from);
 
  {
    SET_FOREACH(entity, e, transferts_from)
    {
      set_add_element(already_transfered_from, already_transfered_from, e);
      set_add_element(array_to_transfer_from_before,
                      array_to_transfer_from_before,
                      e);
      ifdebug(2) {
        string str = strdup(concatenate("Transfert from accel : ",
                                        entity_local_name(e),
                                        "\n",
                                        NULL));
        pips_debug(4,"Inserting : %s\n",str);
        insert_comments_to_statement(st, str);
        free(str);
      }
    }
  }
 
  /* Compute "copy from" sets for the instruction : recursion */
  switch(instruction_tag(i)) {
    case is_instruction_block:
      transfert_block(st,
                      instruction_block( i ),
                      already_transfered_to,
                      already_transfered_from);
      break;
    case is_instruction_test:
      transfert_test(st,
                     instruction_test( i ),
                     already_transfered_to,
                     already_transfered_from,
                     array_to_transfer_to_after,
                     array_to_transfer_from_before);
      break;
    case is_instruction_loop:
      transfert_loop(st,
                     instruction_loop( i ),
                     already_transfered_to,
                     already_transfered_from,
                     array_to_transfer_to_after,
                     array_to_transfer_from_before);
      break;
    case is_instruction_whileloop:
      transfert_whileloop(st,
                          instruction_whileloop( i ),
                          already_transfered_to,
                          already_transfered_from,
                          array_to_transfer_to_after,
                          array_to_transfer_from_before);
      break;
    case is_instruction_forloop:
      transfert_forloop(st,
                        instruction_forloop( i ),
                        already_transfered_to,
                        already_transfered_from,
                        array_to_transfer_to_after,
                        array_to_transfer_from_before);
      break;
    case is_instruction_call:
      transfert_call(st,
                     instruction_call( i ),
                     already_transfered_to,
                     already_transfered_from);
      break;
    case is_instruction_expression:
      /* The second argument is not used */
      transfert_call(st,
                     (call)instruction_expression( i ),
                     already_transfered_to,
                     already_transfered_from);
      break;
    case is_instruction_goto:
      pips_internal_error("Unexpected instruction tag %d: GOTO\n", i);
      break;
    case is_instruction_unstructured:
      transfert_unstructured(st,
                             instruction_unstructured( i ),
                             already_transfered_to,
                             already_transfered_from);
      break;
    default:
      pips_internal_error("Unknown tag %d\n", instruction_tag(i) );
  }
 
 
 
  set killed_transfer = MAKE_SET();
  set_difference(killed_transfer, COPY_TO_OUT(st), COPY_TO_IN(st));
  set_difference(already_transfered_to, already_transfered_to, killed_transfer);
  set_difference(killed_transfer, COPY_FROM_IN(st), COPY_FROM_OUT(st));
  set_difference(already_transfered_from,
                 already_transfered_from,
                 killed_transfer);
  set_free(killed_transfer);
 
}

References compare_entities(), concatenate(), COPY_FROM_IN, COPY_FROM_OUT, COPY_TO_IN, COPY_TO_OUT, entity_local_name(), entity_name, FOREACH, fprintf(), free(), gen_context_recurse, gen_true2(), get_written_entities(), ifdebug, insert_comments_to_statement(), instruction_block, instruction_call, instruction_expression, instruction_forloop, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_block, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, MAKE_SET, pips_debug, pips_internal_error, set_add_element(), set_difference(), SET_FOREACH, set_free(), set_intersection(), set_to_sorted_list(), statement_domain, statement_instruction, statement_number, strdup(), transfert_block(), transfert_call(), transfert_forloop(), transfert_loop(), transfert_test(), transfert_unstructured(), and transfert_whileloop().

Referenced by ikernel_load_store(), kernel_data_mapping(), transfert_block(), transfert_forloop(), transfert_loop(), transfert_test(), and transfert_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

transfert_test()

static void transfert_test ( _UNUSED_ statement  st, test  t, set  already_transfered, set  already_transfered_from, set  transfert_to, set  transfert_from  )

static

Definition at line 1019 of file ikernels.c.

                                               {
  set already_transfered_from_tmp = set_make(set_pointer);
  set already_transfered_tmp = set_make(set_pointer);
  set transfert_to_tmp = set_make(set_pointer);
  set transfert_from_tmp = set_make(set_pointer);
 
  set_assign(already_transfered_from_tmp,already_transfered_from);
  set_assign(already_transfered_tmp,already_transfered);
  set_assign(transfert_to_tmp,transfert_to);
  set_assign(transfert_from_tmp,transfert_from);
 
 
  transfert_statement(test_true(t),
                      already_transfered_tmp,
                      already_transfered_from_tmp,
                      transfert_to_tmp,
                      transfert_from_tmp);
 
 
  set_assign(already_transfered_from_tmp,already_transfered_from);
  set_assign(already_transfered_tmp,already_transfered);
  set_assign(transfert_to_tmp,transfert_to);
  set_assign(transfert_from_tmp,transfert_from);
 
  transfert_statement(test_false(t),
                      already_transfered_tmp,
                      already_transfered_from_tmp,
                      transfert_to_tmp,
                      transfert_from_tmp);
 
 
}

References set_assign(), set_make(), set_pointer, test_false, test_true, and transfert_statement().

Referenced by transfert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

transfert_unstructured()

static void transfert_unstructured ( _UNUSED_ statement  st, _UNUSED_ unstructured  u, _UNUSED_ set  already_transfered, _UNUSED_ set  already_transfered_from  )

static

Definition at line 1144 of file ikernels.c.

                                                                         {
  //pips_user_warning("Unimplemented !! Results may be wrong...\n");
  pips_user_error("Unstructured are not processed. Please structure your input code.\n");
}

References pips_user_error.

Referenced by transfert_statement().

Here is the caller graph for this function:

transfert_whileloop()

static void transfert_whileloop ( _UNUSED_ statement  st, whileloop  l, set  already_transfered, set  already_transfered_from, set  transfert_to, set  transfert_from  )

static

Compute loop body

Definition at line 1108 of file ikernels.c.

                                                    {
  statement body = whileloop_body(l);
 
  /* Compute loop body */
  transfert_statement(body,
                      already_transfered,
                      already_transfered_from,
                      transfert_to,
                      transfert_from);
}

References transfert_statement(), and whileloop_body.

Referenced by transfert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

wrap_argument()

static void wrap_argument ( syntax  s )

static

ize_of_e

Definition at line 1445 of file ikernels.c.

                                    {
  if(syntax_reference_p(s)
      && entity_array_p(reference_variable(syntax_reference(s)))) {
    entity e = reference_variable(syntax_reference(s));
 
 
/*
    sizeofexpression size_of = make_sizeofexpression_expression(transfer_size);
    expression size_of_e;
    size_of_e = make_expression(make_syntax_sizeofexpression(size_of),
                                normalized_undefined);
*/
    syntax new_ref = copy_syntax(s);
    syntax_tag(s) = is_syntax_call;
    list args = make_expression_list(make_expression(new_ref,
                                                     normalized_undefined),
                                                     makeTransfertSizeExpression(e)/*size_of_e*/);
    syntax_call(s) = make_call(wrapper_function,args);
 
    AddEntityToModuleCompilationUnit(wrapper_function, get_current_module_entity());
  }
 
}

References AddEntityToModuleCompilationUnit(), copy_syntax(), entity_array_p(), get_current_module_entity(), is_syntax_call, make_call(), make_expression(), make_expression_list, makeTransfertSizeExpression(), normalized_undefined, reference_variable, syntax_call, syntax_reference, syntax_reference_p, syntax_tag, and wrapper_function.

Referenced by wrap_call_argument().

Here is the call graph for this function:

Here is the caller graph for this function:

wrap_call_argument()

static void wrap_call_argument ( call  c, const char *  module_name  )

static

Definition at line 1469 of file ikernels.c.

                                                                {
  if(!call_intrinsic_p(c)
      && same_string_p(module_local_name(call_function(c)),module_name)) {
 
    list args = call_arguments(c);
    for (expression e; !ENDP(args); POP(args)) {
      e = EXPRESSION(CAR(args));
      gen_recurse(e,syntax_domain,gen_true,wrap_argument);
    }
 
  }
}

References call_arguments, call_function, call_intrinsic_p, CAR, ENDP, EXPRESSION, gen_recurse, gen_true(), module_local_name(), module_name(), POP, same_string_p, syntax_domain, and wrap_argument().

Referenced by wrap_kernel_argument().

Here is the call graph for this function:

Here is the caller graph for this function:

wrap_kernel_argument()

bool wrap_kernel_argument

(

char *

module_name

)

This pass will wrap kernel arguments in a call to a wrapper function.

prelude

o the job

validate

ostlude

Parameters

module_name

odule_name

Definition at line 1486 of file ikernels.c.

                                              {
 
  entity kernel_entity = local_name_to_top_level_entity(module_name);
 
  debug_on("WRAP_KERNEL_ARGUMENT_DEBUG_LEVEL");
 
  callees callers = (callees)db_get_memory_resource(DBR_CALLERS,
                                                    module_name,
                                                    true);
 
  // Get the wrapper function
  const char* function_name = get_string_property("WRAP_KERNEL_ARGUMENT_FUNCTION_NAME");
  wrapper_function = module_name_to_entity(function_name);
  if(entity_undefined_p(wrapper_function)) {
    wrapper_function
        = make_empty_subroutine(function_name,
                                copy_language(module_language(kernel_entity)));
    pips_user_warning("Cannot find \"%s\" method. Are you sure you have set\n"
        "WRAP_KERNEL_ARGUMENT_FUNCTION_NAME"
        "to a defined entity and added the correct .c file?\n",function_name);
  }
 
 
 
 
  FOREACH(STRING,caller_name,callees_callees(callers)) {
    /* prelude */
    set_current_module_entity(module_name_to_entity(caller_name));
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE,
                                                                   caller_name,
                                                                   true));
 
    /*do the job */
    gen_context_recurse(get_current_module_statement(), module_name,
                    call_domain, gen_true2, wrap_call_argument);
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, caller_name,get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, caller_name, compute_callees(get_current_module_statement()));
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
  }
 
  return true;
}

References call_domain, callees_callees, caller_name, compute_callees(), copy_language(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_on, entity_undefined_p, FOREACH, gen_context_recurse, gen_true2(), get_current_module_statement(), get_string_property(), local_name_to_top_level_entity(), make_empty_subroutine(), module_language, module_name(), module_name_to_entity(), module_reorder(), pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), STRING, wrap_call_argument(), and wrapper_function.

Here is the call graph for this function:

Variable Documentation

copies_from_in

hash_table copies_from_in

static

copy_from_in maps each statement to the "copy from" data that are in-coming the statement

Definition at line 150 of file ikernels.c.

Referenced by init_one_statement(), and kernel_data_mapping().

copies_from_out

hash_table copies_from_out

static

copy_from_out maps each statement to the "copy from" data that are out-going from the statement

Definition at line 165 of file ikernels.c.

Referenced by init_one_statement(), and kernel_data_mapping().

copies_to_in

hash_table copies_to_in

static

copy_to_in maps each statement to the "copy to" data that are in-coming the statement

Definition at line 180 of file ikernels.c.

Referenced by init_one_statement(), and kernel_data_mapping().

copies_to_out

hash_table copies_to_out

static

copy_to_out maps each statement to the "copy to" data that are out-going from the statement

Definition at line 195 of file ikernels.c.

Referenced by init_one_statement(), and kernel_data_mapping().

wrapper_function

entity wrapper_function = NULL

static

Definition at line 1442 of file ikernels.c.

Referenced by wrap_argument(), and wrap_kernel_argument().