freia.c File Reference

#include <stdint.h>
#include <stdlib.h>
#include "genC.h"
#include "misc.h"
#include "freia.h"
#include "linear.h"
#include "pipsdbm.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "properties.h"
#include "c_syntax.h"
#include "freia_spoc_private.h"
#include "hwac.h"
#include "effects-generic.h"

Include dependency graph for freia.c:

Go to the source code of this file.

Data Structures
struct	fcs_ctx
struct	fis_ctx
struct	freia_info

Functions
static bool	fcs_call_flt (call c, fcs_ctx *ctx)
static void	freia_cleanup_status (statement s, set helpers)
static bool	fis_call_flt (call c, fis_ctx *ctx)
static bool	freia_image_shuffle (statement s, set shuffled)
static void	sctc_call_rwt (call c, int *count)
static void	switch_cast_to_copy (statement s)
	switch all image casts to image copies in "s" More...
static bool	freia_stmt_free_p (const statement s)
static bool	freia_alloc_call_p (const call c)
static bool	freia_alloc_stat_p (const statement s)
static void	move_ahead (list ls, statement target, sequence sq)
	move statements in l ahead of s in sq note that ls is in reverse order... More...
static int	freia_cmp_statement (const statement *s1, const statement *s2)
	order two statements for qsort. More...
static string	stmt_nb (void *s)
	debug helper More...
static list	clean_list_head (list ls)
	remove non aipo statements at the head of ls More...
static list	clean_statement_list_for_aipo (list ls)
	remove unrelated stuff at head & tail, so that it does not come in later on and possibly trouble the compilation. More...
static void	sort_subsequence (list ls, sequence sq)
	reorder a little bit statements, so that allocs & deallocs are up front or in the back, and may be removed by the previous function. More...
bool	freia_some_effects_on_images (statement s)
	tell whether a statement has no effects on images. More...
static void	update_written_variables (set written, statement s)
	update the set of written variables, as seen from effects, with a statement this is really to rebuild a poor's man dependency graph in order to move some statements around... More...
static bool	statement_depends_p (set written, statement s)
static bool	fsi_loop_flt (__attribute__((unused)) gen_chunk *o, freia_info *fsip)
static void	fsi_loop_rwt (__attribute__((unused)) gen_chunk *o, freia_info *fsip)
expression	freia_transpose_kernel (const expression se)
	Transpose a structuring element expression. More...
bool	freia_is_transpose_call (statement s)
	Detect a call to a se transposition function and transpose the arguments. More...
static bool	fsi_stmt_flt (statement s, freia_info *fsip)
	detect one lone aipo statement out of a sequence... More...
static bool	fsi_seq_flt (sequence sq, freia_info *fsip)
	consider a sequence More...
static _int	min_statement (list ls)
static int	fsi_cmp (const list *l1, const list *l2)
static void	fsi_sort (list lls)
static void	collect_images (reference r, set referenced)
static bool	freia_cleanup_sequence_rec (statement modstat, set referenced)
static bool	freia_cleanup_main_sequence (statement modstat)
string	freia_compile (string module, statement mod_stat, string target)
	freia_compile: compile freia module & statement for target More...

Variables
static hash_table	fsi_number = NULL

Function Documentation

clean_list_head()

static list clean_list_head ( list  ls )

static

remove non aipo statements at the head of ls

Returns

updated list

Definition at line 330 of file freia.c.

{
  list head = ls, prev = NIL;
  while (ls && !freia_statement_aipo_call_p(STATEMENT(CAR(ls))))
    prev = ls, ls = CDR(ls);
  if (prev) CDR(prev) = NIL, gen_free_list(head);
  return ls;
}

References CAR, CDR, freia_statement_aipo_call_p(), gen_free_list(), NIL, and STATEMENT.

Referenced by clean_statement_list_for_aipo().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_statement_list_for_aipo()

static list clean_statement_list_for_aipo ( list  ls )

static

remove unrelated stuff at head & tail, so that it does not come in later on and possibly trouble the compilation.

Returns

updated list

Definition at line 343 of file freia.c.

{
  return gen_nreverse(clean_list_head(gen_nreverse(clean_list_head(ls))));
}

References clean_list_head(), and gen_nreverse().

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_images()

static void collect_images ( reference  r, set  referenced  )

static

Definition at line 705 of file freia.c.

{
  entity var = reference_variable(r);
  if (freia_image_variable_p(var) && !set_belong_p(referenced, var))
    set_add_element(referenced, referenced, var);
}

References freia_image_variable_p(), reference_variable, referenced, set_add_element(), and set_belong_p().

Referenced by freia_cleanup_sequence_rec().

Here is the call graph for this function:

Here is the caller graph for this function:

fcs_call_flt()

static bool fcs_call_flt ( call  c, fcs_ctx *  ctx  )

static

Definition at line 60 of file freia.c.

{
  entity called = call_function(c);
  if (freia_assignment_p(called))
  {
    list largs = call_arguments(c);
    pips_assert("two arguments to = or |=", gen_length(largs)==2);
    expression erhs = EXPRESSION(CAR(CDR(largs)));
 
    // catch and eat-up "foo |= 0;"
    _int val;
    if (ENTITY_BITWISE_OR_UPDATE_P(called) &&
        expression_integer_value(erhs, &val) && val==0)
    {
      call_function(c) = entity_intrinsic(CONTINUE_FUNCTION_NAME);
      gen_free_list(call_arguments(c)), call_arguments(c) = NIL;
      return false;
    }
 
    // else, is it a call to some aipo or helper function?
    syntax op = expression_syntax(erhs);
    if (!syntax_call_p(op))
      return false;
 
    // is it an aipo or helper call?
    call rhs = syntax_call(op);
    if (entity_freia_api_p(call_function(rhs)) ||
        (ctx->helper_functions &&
         set_belong_p(ctx->helper_functions, call_function(rhs))))
    {
      // record scrapped status variable
      syntax slhs = expression_syntax(EXPRESSION(CAR(largs)));
      pips_assert("left hand side is a scalar reference",
                  syntax_reference_p(slhs) &&
                  !reference_indices(syntax_reference(slhs)));
      set_add_element(ctx->used_for_status, ctx->used_for_status,
                      reference_variable(syntax_reference(slhs)));
 
      // and scrap its assignement!
      call_function(c) = call_function(rhs);
      call_arguments(c) = call_arguments(rhs);
 
      // hmmm... small memory leak in assigned lhs,
      // but I'm not sure of effect references...
      call_arguments(rhs) = NIL;
      free_call(rhs);
      gen_free_list(largs);
    }
  }
  // no second level anyway? what about ","?
  return false;
}

References call_arguments, call_function, CAR, CDR, CONTINUE_FUNCTION_NAME, ENTITY_BITWISE_OR_UPDATE_P, entity_freia_api_p(), entity_intrinsic(), EXPRESSION, expression_integer_value(), expression_syntax, free_call(), freia_assignment_p(), gen_free_list(), gen_length(), fcs_ctx::helper_functions, NIL, pips_assert, reference_indices, reference_variable, set_add_element(), set_belong_p(), syntax_call, syntax_call_p, syntax_reference, syntax_reference_p, and fcs_ctx::used_for_status.

Referenced by freia_cleanup_status().

Here is the call graph for this function:

Here is the caller graph for this function:

fis_call_flt()

static bool fis_call_flt ( call  c, fis_ctx *  ctx  )

static

Definition at line 148 of file freia.c.

{
  list args = call_arguments(c);
  if (ENTITY_ASSIGN_P(call_function(c)))
  {
    pips_assert("assign takes two args", gen_length(args)==2);
    entity a1 = expression_to_entity(EXPRESSION(CAR(args)));
    entity a2 = expression_to_entity(EXPRESSION(CAR(CDR(args))));
    if (a2!=entity_undefined &&
        freia_image_variable_p(a1) && freia_image_variable_p(a2))
    {
      set_add_element(ctx->shuffled, ctx->shuffled, a1);
      set_add_element(ctx->shuffled, ctx->shuffled, a2);
      return false;
    }
  }
  return true;
}

References call_arguments, call_function, CAR, CDR, ENTITY_ASSIGN_P, entity_undefined, EXPRESSION, expression_to_entity(), freia_image_variable_p(), gen_length(), pips_assert, set_add_element(), and fis_ctx::shuffled.

Referenced by freia_image_shuffle().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_alloc_call_p()

static bool freia_alloc_call_p ( const call  c )

static

Definition at line 209 of file freia.c.

{
  entity f = call_function(c);
  const char *called = entity_user_name(f);
  return same_string_p(called, FREIA_ALLOC) ||
         same_string_p(called, FREIA_FREE);
}

References call_function, entity_user_name(), f(), FREIA_ALLOC, FREIA_FREE, and same_string_p.

Referenced by freia_alloc_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_alloc_stat_p()

static bool freia_alloc_stat_p ( const statement  s )

static

Definition at line 217 of file freia.c.

{
  call c = freia_statement_to_call(s);
  if (c == NULL)
    return false;
  entity f = call_function(c);
  if (ENTITY_CONTINUE_P(f))
  {
    FOREACH(entity, var, statement_declarations(s))
    {
      value val = entity_initial(var);
      if (value_expression_p(val))
      {
        expression eval = value_expression(val);
        if (expression_call_p(eval) &&
            ! freia_alloc_call_p(expression_call(eval)))
          return false;
      }
      else if (!value_unknown_p(val))
        return false;
    }
    return true;
  }
  else
    return freia_alloc_call_p(c);
}

References call_function, ENTITY_CONTINUE_P, entity_initial, eval(), expression_call(), expression_call_p(), f(), FOREACH, freia_alloc_call_p(), freia_statement_to_call(), statement_declarations, value_expression, value_expression_p, and value_unknown_p.

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_cleanup_main_sequence()

static bool freia_cleanup_main_sequence ( statement  modstat )

static

Definition at line 768 of file freia.c.

{
  set referenced = set_make(set_pointer);
  bool changed = freia_cleanup_sequence_rec(modstat, referenced);
  set_free(referenced);
  return changed;
}

References freia_cleanup_sequence_rec(), referenced, set_free(), set_make(), and set_pointer.

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_cleanup_sequence_rec()

static bool freia_cleanup_sequence_rec ( statement  modstat, set  referenced  )

static

Definition at line 712 of file freia.c.

{
  //fprintf(stderr, "[freia_cleanup_main_sequence] %p\n", modstat);
  bool changed = false;
  instruction i = statement_instruction(modstat);
 
  if (instruction_sequence_p(i))
  {
    sequence seq = instruction_sequence(i);
    list rstats = gen_nreverse(gen_copy_seq(sequence_statements(seq)));
    // set of referenced images
 
    FOREACH(statement, s, rstats)
    {
      // handle seqs in seqs with an explicit recursion
      if (statement_sequence_p(s))
        changed = freia_cleanup_sequence_rec(s, referenced);
      else if (freia_statement_aipo_call_p(s))
      {
        call c = freia_statement_to_call(s);
        const freia_api_t * api =
          hwac_freia_api(entity_local_name(call_function(c)));
        if (api->arg_img_out==1)
        {
          entity img = expression_to_entity(EXPRESSION(CAR(call_arguments(c))));
          //fprintf(stderr, "considering %s on %s\n",
          //        api->function_name, entity_local_name(img));
          if (!set_belong_p(referenced, img) &&
              // hey, we keep written parameters!
              // ??? what about global images, if any?
              !formal_parameter_p(img))
          {
            changed = true;
            free_instruction(statement_instruction(s));
            statement_instruction(s) = make_continue_instruction();
          }
        }
      }
      // update seen variables, but must skip deallocations!
      // ??? what about skipping alloc as well?
      if (!is_freia_dealloc(s))
        gen_context_recurse(s, referenced,
                            // could also do loop indexes, but no images
                            reference_domain, gen_true2, collect_images);
      // also look in initializations
      FOREACH(entity, var, statement_declarations(s))
        gen_context_recurse(entity_initial(var), referenced,
                            reference_domain, gen_true2, collect_images);
 
    }
 
    gen_free_list(rstats);
  }
  return changed;
}

References freia_api_t::arg_img_out, call_arguments, call_function, CAR, collect_images(), entity_initial, entity_local_name(), EXPRESSION, expression_to_entity(), FOREACH, formal_parameter_p(), free_instruction(), freia_statement_aipo_call_p(), freia_statement_to_call(), gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_nreverse(), gen_true2(), hwac_freia_api(), instruction_sequence, instruction_sequence_p, is_freia_dealloc(), make_continue_instruction(), reference_domain, referenced, sequence_statements, set_belong_p(), statement_declarations, statement_instruction, and statement_sequence_p().

Referenced by freia_cleanup_main_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_cleanup_status()

static void freia_cleanup_status ( statement  s, set  helpers  )

static

Definition at line 120 of file freia.c.

{
  fcs_ctx ctx = { set_make(set_pointer), helpers };
 
  // cleanup statements
  gen_context_recurse(s, &ctx, call_domain, fcs_call_flt, gen_null2);
 
  // fix status variable initializations
  SET_FOREACH(entity, var, ctx.used_for_status)
  {
    if (value_unknown_p(entity_initial(var)))
    {
      free_value(entity_initial(var));
      entity_initial(var) =
        make_value_expression(call_to_expression(freia_ok()));
    }
  }
 
  // cleanup
  set_free(ctx.used_for_status);
}

References call_domain, call_to_expression(), entity_initial, fcs_call_flt(), free_value(), freia_ok(), gen_context_recurse, gen_null2(), make_value_expression(), SET_FOREACH, set_free(), set_make(), set_pointer, fcs_ctx::used_for_status, and value_unknown_p.

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_cmp_statement()

static int freia_cmp_statement ( const statement *  s1, const statement *  s2  )

static

order two statements for qsort.

s1 before s2 => -1

Definition at line 279 of file freia.c.

{
  const call
    c1 = statement_call_p(*s1)?
      instruction_call(statement_instruction((statement) *s1)): NULL,
    c2 = statement_call_p(*s2)?
      instruction_call(statement_instruction((statement) *s2)): NULL;
  bool
    s1r = c1? ENTITY_C_RETURN_P(call_function(c1)): false,
    s2r = c2? ENTITY_C_RETURN_P(call_function(c2)): false,
    s1a = is_freia_alloc(*s1), s2a = is_freia_alloc(*s2),
    s1d = is_freia_dealloc(*s1), s2d = is_freia_dealloc(*s2);
  if (s1r || s2r) pips_assert("one return in sequence", s1r ^ s2r);
 
  pips_debug(9, "%"_intFMT" %s is %d %d %d\n", statement_number(*s1),
             c1? entity_name(call_function(c1)): "", s1r, s1a, s1d);
  pips_debug(9, "%"_intFMT" %s is %d %d %d\n", statement_number(*s2),
             c2? entity_name(call_function(c2)): "", s2r, s2a, s2d);
 
  int order = 0;
  string why = "";
 
  // return at the back, obviously...
  if (s1r) order = 1, why = "return1";
  else if (s2r) order = -1, why = "return2";
  // allocs at the front (there may be in initialisations, which up front)
  else if (s1a && !s2a) order = -1, why = "alloc1";
  else if (s2a && !s1a) order = 1, why = "alloc2";
  // deallocs at the back
  else if (s1d && !s2d) order = 1, why = "free1";
  else if (s2d && !s1d) order = -1, why = "free2";
  // else keep statement initial order
  else order = statement_number(*s1)-statement_number(*s2), why = "stat";
 
  pips_assert("total order", order!=0);
 
  pips_debug(7, "%"_intFMT" %s %"_intFMT" (%s)\n", statement_number(*s1),
             order==-1? "<": ">", statement_number(*s2), why);
 
  return order;
}

References _intFMT, call_function, ENTITY_C_RETURN_P, entity_name, instruction_call, is_freia_alloc(), is_freia_dealloc(), pips_assert, pips_debug, s1, statement_call_p(), statement_instruction, and statement_number.

Referenced by sort_subsequence().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_compile()

string freia_compile	(	string	module,
		statement	mod_stat,
		string	target
	)

freia_compile: compile freia module & statement for target

• do some cleanup on sequences
• collect sequences of freia operations
• create file for generated functions
• call hardware-specific code generation for each sequence

Parameters

module	odule
mod_stat	od_stat
target	arget

Definition at line 785 of file freia.c.

{
  pips_assert("we need some dependable effects for our purpose",
              !get_bool_property("CONSTANT_PATH_EFFECTS"));
 
  if (!freia_valid_target_p(target))
    pips_internal_error("unexpected target %s", target);
 
  // deal with some simple image shuff cases by forward substitution
  freia_shuffle_move_forward(mod_stat);
 
  // check for remaining image shuffles...
  set shuffled = set_make(set_pointer);
  if (freia_image_shuffle(mod_stat, shuffled))
  {
    if (get_bool_property("FREIA_ALLOW_IMAGE_SHUFFLE"))
      pips_user_warning("image shuffle found in %s, "
                        "freia compilation may result in wrong code!\n",
                        module);
    else
      pips_user_error("image shuffle found in %s, "
                      "see FREIA_ALLOW_IMAGE_SHUFFLE property to continue.\n",
                      module);
  }
 
  // freia_aipo_cast -> freia_aipo_copy before further compilation
  if (get_bool_property("FREIA_CAST_IS_COPY"))
    switch_cast_to_copy(mod_stat);
 
  freia_info fsi =
    { NIL, hash_table_make(hash_pointer, 0), 0, set_make(set_pointer) };
  freia_init_dep_cache();
 
  // collect freia api functions...
  gen_context_multi_recurse(mod_stat, &fsi,
                            // collect sequences
                            sequence_domain, fsi_seq_flt, gen_null,
                            statement_domain, fsi_stmt_flt, gen_null,
                            // just count potential enclosing loops...
                            loop_domain, fsi_loop_flt, fsi_loop_rwt,
                            whileloop_domain, fsi_loop_flt, fsi_loop_rwt,
                            forloop_domain, fsi_loop_flt, fsi_loop_rwt,
                            unstructured_domain, fsi_loop_flt, fsi_loop_rwt,
                            NULL);
 
  // check safe return
  pips_assert("loop count back to zero", fsi.enclosing_loops==0);
 
  // sort sequences by increasing statement numbers
  fsi_sort(fsi.seqs);
 
  // output file if any
  string file = NULL;
  set helpers = NULL;
  FILE * helper = NULL;
  if (freia_spoc_p(target) || freia_terapix_p(target) ||
      freia_opencl_p(target) || freia_sigmac_p(target) || freia_mppa_p(target))
  {
    file = helper_file_name(module, "c");
    if (file_readable_p(file))
      pips_user_error("file '%s' already exists: "
                      "cannot reapply transformation\n", file);
    helper = safe_fopen(file, "w");
    pips_debug(1, "generating file '%s'\n", file);
 
    // we will also record created helpers
    helpers = set_make(set_pointer);
  }
 
  // headers
  if (freia_spoc_p(target))
    fprintf(helper, "%s", FREIA_SPOC_INCLUDES);
  else if (freia_terapix_p(target))
    fprintf(helper, "%s", FREIA_TRPX_INCLUDES);
  else if (freia_opencl_p(target))
    fprintf(helper, "%s", FREIA_OPENCL_INCLUDES);
  else if (freia_sigmac_p(target))
    fprintf(helper, "%s", FREIA_SIGMAC_INCLUDES);
  else if (freia_mppa_p(target))
    fprintf(helper, "%s", FREIA_MPPA_INCLUDES);
 
  // hmmm... should rely on use-defs
  hash_table occs = freia_build_image_occurrences(mod_stat, NULL, NULL, NULL);
  set output_images = freia_compute_current_output_images();
  // hmmm... panic mode
  set_union(output_images, output_images, shuffled);
 
  // first explicitely build and fix the list of dags,
  // with some reverse order hocus-pocus for outputs computations...
  list lsi = gen_nreverse(gen_copy_seq(fsi.seqs));
  list ldags = NIL;
  int n_dags = gen_length(fsi.seqs);
  FOREACH(list, ls, lsi)
  {
    dag d = freia_build_dag(module, ls, --n_dags, occs, output_images, ldags,
                            set_belong_p(fsi.in_loops, ls));
    ldags = CONS(dag, d, ldags);
  }
  gen_free_list(lsi), lsi = NIL;
 
  list lcurrent = ldags;
  // signatures definition must be cross-dag because of
  // dilate/erode helper reuse with OpenCL
  hash_table signatures = hash_table_make(hash_pointer, 0);
  n_dags = 0;
  bool compile_lone = get_bool_property("FREIA_COMPILE_LONE_OPERATIONS");
  FOREACH(list, ls, fsi.seqs)
  {
    // get corresponding dag, which should be destroyed by the called compiler
    dag d = DAG(CAR(lcurrent));
    lcurrent = CDR(lcurrent);
 
    // maybe skip lone operations
    if (!compile_lone && gen_length(ls)==1)
    {
      n_dags++;
      gen_free_list(ls);
      continue;
    }
 
    list allocated = NIL;
    hash_table exchanges = NULL;
    sequence sq = NULL;
    if (hash_defined_p(fsi.sequence, ls))
    {
      exchanges = hash_table_make(hash_pointer, 0);
      sq = hash_get(fsi.sequence, ls);
    }
 
    if (freia_spoc_p(target))
      allocated = freia_spoc_compile_calls(module, d, sq, ls, occs, exchanges,
                                       output_images, helper, helpers, n_dags);
    else if (freia_terapix_p(target))
      allocated = freia_trpx_compile_calls(module, d, sq, ls, occs, exchanges,
                                       output_images, helper, helpers, n_dags);
    else if (freia_opencl_p(target))
      allocated = freia_opencl_compile_calls(module, d, sq, ls, occs, exchanges,
                           output_images, helper, helpers, n_dags, signatures);
    else if (freia_sigmac_p(target))
      allocated = freia_sigmac_compile_calls(module, d, sq, ls, occs, exchanges,
              output_images, helper, helpers, n_dags, gen_length(fsi.seqs));
    else if (freia_mppa_p(target))
      allocated =
          freia_mppa_compile_calls(module, d, sq, ls, occs, exchanges,
                                   output_images, helper, helpers, n_dags);
    else if (freia_aipo_p(target))
      allocated = freia_aipo_compile_calls(module, d, ls, occs, exchanges,
                                           n_dags);
 
    if (exchanges)
    {
      list lssq = sequence_statements((sequence) hash_get(fsi.sequence, ls));
      HASH_FOREACH(dagvtx, v1, dagvtx, v2, exchanges)
        gen_exchange_in_list(lssq, dagvtx_statement(v1), dagvtx_statement(v2));
    }
 
    if (allocated)
    {
      FOREACH(entity, img, allocated)
        add_declaration_statement(mod_stat, img);
      gen_free_list(allocated);
    }
 
    n_dags++;
 
    // cleanup list contents on the fly
    gen_free_list(ls);
    free_dag(d);
    if (exchanges) hash_table_free(exchanges);
  }
 
  // some code cleanup
  freia_cleanup_main_sequence(mod_stat);
 
  // some more code cleanup
  if (get_bool_property("FREIA_CLEANUP_STATUS"))
    // remove err = or err |= freia & helper functions
    freia_cleanup_status(mod_stat, helpers);
 
  // cleanup
  freia_clean_image_occurrences(occs);
  freia_close_dep_cache();
  set_free(output_images), output_images = NULL;
  set_free(shuffled), shuffled = NULL;
  if (helpers) set_free(helpers), helpers = NULL;
  gen_free_list(fsi.seqs);
  set_free(fsi.in_loops);
  hash_table_free(fsi.sequence);
  hash_table_free(signatures);
  gen_free_list(ldags);
  if (helper) safe_fclose(helper, file);
 
  return file;
}

References add_declaration_statement(), CAR, CDR, CONS, DAG, dagvtx_statement(), freia_info::enclosing_loops, file_readable_p(), FOREACH, forloop_domain, fprintf(), free_dag(), freia_aipo_compile_calls(), freia_aipo_p, freia_build_dag(), freia_build_image_occurrences(), freia_clean_image_occurrences(), freia_cleanup_main_sequence(), freia_cleanup_status(), freia_close_dep_cache(), freia_compute_current_output_images(), freia_image_shuffle(), freia_init_dep_cache(), freia_mppa_compile_calls(), FREIA_MPPA_INCLUDES, freia_mppa_p, freia_opencl_compile_calls(), FREIA_OPENCL_INCLUDES, freia_opencl_p, freia_shuffle_move_forward(), freia_sigmac_compile_calls(), FREIA_SIGMAC_INCLUDES, freia_sigmac_p, freia_spoc_compile_calls(), FREIA_SPOC_INCLUDES, freia_spoc_p, freia_terapix_p, freia_trpx_compile_calls(), FREIA_TRPX_INCLUDES, freia_valid_target_p, fsi_loop_flt(), fsi_loop_rwt(), fsi_seq_flt(), fsi_sort(), fsi_stmt_flt(), gen_context_multi_recurse(), gen_copy_seq(), gen_exchange_in_list(), gen_free_list(), gen_length(), gen_nreverse(), gen_null(), get_bool_property(), hash_defined_p(), HASH_FOREACH, hash_get(), hash_pointer, hash_table_free(), hash_table_make(), helper_file_name(), freia_info::in_loops, loop_domain, mod_stat, module, n_dags, NIL, pips_assert, pips_debug, pips_internal_error, pips_user_error, pips_user_warning, safe_fclose(), safe_fopen(), freia_info::seqs, freia_info::sequence, sequence_domain, sequence_statements, set_belong_p(), set_free(), set_make(), set_pointer, set_union(), statement_domain, switch_cast_to_copy(), unstructured_domain, and whileloop_domain.

Referenced by freia_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_image_shuffle()

static bool freia_image_shuffle ( statement  s, set  shuffled  )

static

Returns

whether there is an image shuffle, i.e. image pointer assignments

Definition at line 169 of file freia.c.

{
  fis_ctx ctx = { shuffled };
  gen_context_recurse(s, &ctx, call_domain, fis_call_flt, gen_null2);
  return set_size(shuffled)!=0;
}

References call_domain, fis_call_flt(), gen_context_recurse, gen_null2(), and set_size().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_is_transpose_call()

bool freia_is_transpose_call

(

statement

s

)

Detect a call to a se transposition function and transpose the arguments.

The expected function should have the following signature transpose_func(int kernelOut[9], const int kernelIn[9], ...)

Definition at line 499 of file freia.c.

                                          {
 
  if (statement_call_p(s)) {
    call c = statement_call(s);
    if (c) {
      entity called = call_function(c);
 
      // extract transposition calls
      if (same_string_p(entity_local_name(called),
                        get_string_property("FREIA_TRANSPOSE_KERNEL_FUNC"))) {
 
        list args = call_arguments(c);
        pips_assert("an expected transposition function should have at least "
                    "two arguments",
                    gen_length(args) >= 2);
 
        // get the argument entities
        entity se = expression_to_entity(EXPRESSION(CAR(CDR(args))));
        entity trse = expression_to_entity(EXPRESSION(CAR(args)));
 
        if (value_expression_p(entity_initial(se))) {
          // get the expression value of the initial structuring element
          expression seval = value_expression(entity_initial(se));
          // effectively transpose structuring element
          expression trseval = freia_transpose_kernel(seval);
 
          // set the value of the transposed structuring element
          set_entity_initial(trse, trseval);
 
          pips_debug(9, "%s: out %s, in %s\n", entity_local_name(called),
                     expression_to_string(trseval),
                     expression_to_string(seval));
        }
 
        return true;
      }
    }
  }
  return false;
}

References call_arguments, call_function, CAR, CDR, entity_initial, entity_local_name(), EXPRESSION, expression_to_entity(), expression_to_string(), freia_transpose_kernel(), gen_length(), get_string_property(), pips_assert, pips_debug, same_string_p, set_entity_initial(), statement_call(), statement_call_p(), value_expression, and value_expression_p.

Referenced by fsi_stmt_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_some_effects_on_images()

bool freia_some_effects_on_images

(

statement

s

)

tell whether a statement has no effects on images.

freia.c

if so, it may be included somehow in the pipeline and just skipped, provided stat scalar dependencies are taken care of.

Definition at line 402 of file freia.c.

{
  int img_effect = false;
  list cumu = effects_effects(load_cumulated_rw_effects(s));
  FOREACH(effect, e, cumu)
  {
    if (freia_image_variable_p(effect_variable(e)))
    {
      img_effect = true;
      break;
    }
  }
  return img_effect;
}

References effect_variable, effects_effects, FOREACH, freia_image_variable_p(), and load_cumulated_rw_effects().

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_stmt_free_p()

static bool freia_stmt_free_p ( const statement  s )

static

Definition at line 202 of file freia.c.

{
  call c = freia_statement_to_call(s);
  const char* called = c? entity_user_name(call_function(c)): "";
  return same_string_p(called, FREIA_FREE);
}

References call_function, entity_user_name(), FREIA_FREE, freia_statement_to_call(), and same_string_p.

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_transpose_kernel()

expression freia_transpose_kernel

(

const expression

se

)

Transpose a structuring element expression.

Parameters

se

e

Definition at line 479 of file freia.c.

                                                       {
  // get the structuring element array
  list vals = call_arguments(syntax_call(expression_syntax(se)));
  entity fun = call_function(syntax_call(expression_syntax(se)));
 
  // reverse it...
  list vals_rev = gen_nreverse(gen_full_copy_list(vals));
 
  // build the expression
  return make_expression(make_syntax_call(make_call(fun, vals_rev)),
                         expression_normalized(se));
}

References call_arguments, call_function, expression_normalized, expression_syntax, gen_full_copy_list(), gen_nreverse(), make_call(), make_expression(), make_syntax_call(), and syntax_call.

Referenced by freia_is_transpose_call().

Here is the call graph for this function:

Here is the caller graph for this function:

fsi_cmp()

static int fsi_cmp ( const list *  l1, const list *  l2  )

static

Definition at line 681 of file freia.c.

{
  return (int) ((_int) hash_get(fsi_number, *l1) -
                (_int) hash_get(fsi_number, *l2));
}

References fsi_number, and hash_get().

Referenced by fsi_sort().

Here is the call graph for this function:

Here is the caller graph for this function:

fsi_loop_flt()

static bool fsi_loop_flt ( __attribute__((unused)) gen_chunk *  o, freia_info *  fsip  )

static

Definition at line 463 of file freia.c.

{
  fsip->enclosing_loops++;
  return true;
}

References freia_info::enclosing_loops.

Referenced by freia_compile().

Here is the caller graph for this function:

fsi_loop_rwt()

static void fsi_loop_rwt ( __attribute__((unused)) gen_chunk *  o, freia_info *  fsip  )

static

Definition at line 470 of file freia.c.

{
  fsip->enclosing_loops--;
}

References freia_info::enclosing_loops.

Referenced by freia_compile().

Here is the caller graph for this function:

fsi_seq_flt()

static bool fsi_seq_flt ( sequence  sq, freia_info *  fsip  )

static

consider a sequence

of statements

Definition at line 559 of file freia.c.

{
  pips_debug(9, "considering sequence...\n");
 
  list /* of statements */ ls = NIL, ltail = NIL, lup = NIL;
 
  // use a copy, because the sequence is rewritten inside the loop...
  // see sort_subsequence. I guess should rather delay it...
  list lseq = gen_copy_seq(sequence_statements(sq));
 
  set written = set_make(set_pointer);
 
  FOREACH(statement, s, lseq)
  {
    bool freia_api = freia_statement_aipo_call_p(s);
    // the statement is kept if
    bool keep_stat =
      // it is an AIPO call
      freia_api ||
      // it follows kept calls and
      (ls && (
        // it is an (image) allocation in the middle of the code
        freia_alloc_stat_p(s) ||
        // or it has no image effects
        !freia_some_effects_on_images(s)));
 
    // quick fix for performance: stop on timer calls
    if (keep_stat && statement_call_p(s))
    {
      entity called = call_function(statement_call(s));
      if (same_string_p(entity_local_name(called), "gettimeofday") ||
          same_string_p(entity_local_name(called), "freia_common_wait"))
        keep_stat = false;
    }
 
    pips_debug(7, "statement %"_intFMT": %skept\n",
               statement_number(s), keep_stat? "": "not ");
 
    // FREIA API & "intermediate" statements are kept
    if (keep_stat)
    {
      if (freia_api)
      {
        ls = gen_nconc(ltail, ls), ltail = NIL;
        ls = CONS(statement, s, ls);
        update_written_variables(written, s);
      }
      else // else accumulate in the "other list" waiting for something...
      {
        if (statement_depends_p(written, s) ||
            (statement_call_p(s) &&
             ENTITY_C_RETURN_P(call_function(statement_call(s)))) ||
            // free are kept in the tail... not caught as a W effect?
            freia_stmt_free_p(s))
        {
          pips_debug(8, "statement %d in ltail\n", (int) statement_number(s));
          ltail = CONS(statement, s, ltail);
          update_written_variables(written, s);
        }
        else
        {
          pips_debug(8, "statement %d in lup\n", (int) statement_number(s));
          // we can move it up...
          lup = CONS(statement, s, lup);
        }
      }
    }
    else // the sequence must be cut on this statement
    {
      if (lup && ls)
        move_ahead(lup, STATEMENT(CAR(gen_last(ls))), sq);
      if (lup) gen_free_list(lup), lup = NIL;
      if (ls!=NIL)
      {
        sort_subsequence(ls, sq);
        ls = clean_statement_list_for_aipo(ls);
        fsip->seqs = CONS(list, ls, fsip->seqs);
        hash_put(fsip->sequence, ls, sq);
        if (fsip->enclosing_loops)
          set_add_element(fsip->in_loops, fsip->in_loops, ls);
        ls = NIL;
      }
      if (ltail) gen_free_list(ltail), ltail = NIL;
      set_clear(written);
    }
  }
 
  // end of sequence reached
  if (ls!=NIL)
  {
    if (lup && ls)
      move_ahead(lup, STATEMENT(CAR(gen_last(ls))), sq);
    sort_subsequence(ls, sq);
    ls = clean_statement_list_for_aipo(ls);
    fsip->seqs = CONS(list, ls, fsip->seqs);
    hash_put(fsip->sequence, ls, sq);
    if (fsip->enclosing_loops)
      set_add_element(fsip->in_loops, fsip->in_loops, ls);
    ls = NIL;
  }
 
  // cleanup
  if (ltail) gen_free_list(ltail), ltail = NIL;
  if (lup) gen_free_list(lup), lup = NIL;
  gen_free_list(lseq);
  set_free(written);
  return true;
}

References _intFMT, call_function, CAR, clean_statement_list_for_aipo(), CONS, freia_info::enclosing_loops, ENTITY_C_RETURN_P, entity_local_name(), FOREACH, freia_alloc_stat_p(), freia_some_effects_on_images(), freia_statement_aipo_call_p(), freia_stmt_free_p(), gen_copy_seq(), gen_free_list(), gen_last(), gen_nconc(), hash_put(), freia_info::in_loops, move_ahead(), NIL, pips_debug, same_string_p, freia_info::seqs, freia_info::sequence, sequence_statements, set_add_element(), set_clear(), set_free(), set_make(), set_pointer, sort_subsequence(), STATEMENT, statement_call(), statement_call_p(), statement_depends_p(), statement_number, update_written_variables(), and written.

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

fsi_sort()

static void fsi_sort ( list  lls )

static

Definition at line 687 of file freia.c.

{
  pips_assert("static fsi_number is clean", !fsi_number);
  fsi_number = hash_table_make(hash_pointer, 0);
  FOREACH(list, ls, lls)
    hash_put(fsi_number, ls, (void*) min_statement(ls));
  gen_sort_list(lls, (gen_cmp_func_t) fsi_cmp);
  hash_table_free(fsi_number), fsi_number = NULL;
}

References FOREACH, fsi_cmp(), fsi_number, gen_sort_list(), hash_pointer, hash_put(), hash_table_free(), hash_table_make(), min_statement(), and pips_assert.

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

fsi_stmt_flt()

static bool fsi_stmt_flt ( statement  s, freia_info *  fsip  )

static

detect one lone aipo statement out of a sequence...

Definition at line 542 of file freia.c.

{
  freia_is_transpose_call(s);
  if (freia_statement_aipo_call_p(s))
  {
    instruction i = (instruction) gen_get_ancestor(instruction_domain, s);
    if (i && instruction_sequence_p(i)) return false;
    // not a sequence handled by fsi_seq_flt...
    list ls = CONS(statement, s, NIL);
    fsip->seqs = CONS(list, ls, fsip->seqs);
    if (fsip->enclosing_loops)
      set_add_element(fsip->in_loops, fsip->in_loops, ls);
  }
  return true;
}

References CONS, freia_info::enclosing_loops, freia_is_transpose_call(), freia_statement_aipo_call_p(), gen_get_ancestor(), freia_info::in_loops, instruction_domain, instruction_sequence_p, NIL, freia_info::seqs, and set_add_element().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

min_statement()

static _int min_statement ( list  ls )

static

Definition at line 670 of file freia.c.

{
  _int min = -1;
  FOREACH(statement, s, ls)
    min = (min==-1)? statement_number(s):
    (min<statement_number(s)? min: statement_number(s));
  return min;
}

References FOREACH, min, and statement_number.

Referenced by fsi_sort().

Here is the caller graph for this function:

move_ahead()

static void move_ahead ( list  ls, statement  target, sequence  sq  )

static

move statements in l ahead of s in sq note that ls is in reverse order...

Definition at line 247 of file freia.c.

{
  // for faster list inclusion test
  set tomove = set_make(set_pointer);
  set_append_list(tomove, ls);
 
  // build new sequence list in reverse order
  list nsq = NIL;
  FOREACH(statement, s, sequence_statements(sq))
  {
    if (set_belong_p(tomove, s))
      continue; // skip!
    if (s==target)
      // insert list now!
      nsq = gen_nconc(gen_copy_seq(ls), nsq);
    // and keep current statement
    nsq = CONS(statement, s, nsq);
  }
 
  // update sequence with new list
  gen_free_list(sequence_statements(sq));
  sequence_statements(sq) = gen_nreverse(nsq);
 
  // clean up
  set_free(tomove);
}

References CONS, FOREACH, gen_copy_seq(), gen_free_list(), gen_nconc(), gen_nreverse(), NIL, sequence_statements, set_append_list(), set_belong_p(), set_free(), set_make(), and set_pointer.

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

sctc_call_rwt()

static void sctc_call_rwt ( call  c, int *  count  )

static

Definition at line 178 of file freia.c.

{
  entity func = call_function(c);
  if (same_string_p(entity_local_name(func), AIPO "cast"))
  {
    call_function(c) = local_name_to_top_level_entity(AIPO "copy");
    (*count)++;
  }
}

References AIPO, call_function, entity_local_name(), local_name_to_top_level_entity(), and same_string_p.

Referenced by switch_cast_to_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

sort_subsequence()

static void sort_subsequence ( list  ls, sequence  sq  )

static

reorder a little bit statements, so that allocs & deallocs are up front or in the back, and may be removed by the previous function.

Definition at line 351 of file freia.c.

{
  ifdebug(8) {
    pips_debug(8, "input: ");
    gen_fprint(stderr, "ls", ls, (gen_string_func_t) stmt_nb);
  }
 
  set cmp = set_make(set_pointer);
  set_assign_list(cmp, ls);
 
  // sort ls
  gen_sort_list(ls, (gen_cmp_func_t) freia_cmp_statement);
 
  // extract sub sequence in a separate list
  list head = NIL, lcmp = NIL, tail = NIL;
  FOREACH(statement, s, sequence_statements(sq))
  {
    if (set_belong_p(cmp, s))
      lcmp = CONS(statement, s, lcmp);
    else
      if (!lcmp)
        head = CONS(statement, s, head);
      else
        tail = CONS(statement, s, tail);
  }
 
  // sort subsequence
  gen_sort_list(lcmp, (gen_cmp_func_t) freia_cmp_statement);
 
  // rebuild sequence
  gen_free_list(sequence_statements(sq));
  sequence_statements(sq) =
    gen_nconc(gen_nreverse(head), gen_nconc(lcmp, gen_nreverse(tail)));
 
  set_free(cmp);
 
  ifdebug(8) {
    pips_debug(8, "output: ");
    gen_fprint(stderr, "ls", ls, (gen_string_func_t) stmt_nb);
  }
}

References CONS, FOREACH, freia_cmp_statement(), gen_fprint(), gen_free_list(), gen_nconc(), gen_nreverse(), gen_sort_list(), ifdebug, NIL, pips_debug, sequence_statements, set_assign_list(), set_belong_p(), set_free(), set_make(), set_pointer, and stmt_nb().

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_depends_p()

static bool statement_depends_p ( set  written, statement  s  )

static

Returns

whether statement depends on some written variables

Definition at line 434 of file freia.c.

{
  bool depends = false;
  list cumu = effects_effects(load_cumulated_rw_effects(s));
  FOREACH(effect, e, cumu)
  {
    if (effect_read_p(e) && set_belong_p(written, effect_variable(e)))
    {
      depends = true;
      break;
    }
  }
  return depends;
}

References effect_read_p, effect_variable, effects_effects, FOREACH, load_cumulated_rw_effects(), set_belong_p(), and written.

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

stmt_nb()

static string stmt_nb ( void *  s )

static

debug helper

Definition at line 322 of file freia.c.

{
  return i2a((int) statement_number((statement) s));
}

References i2a(), and statement_number.

Referenced by sort_subsequence().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_cast_to_copy()

static void switch_cast_to_copy ( statement  s )

static

switch all image casts to image copies in "s"

Definition at line 190 of file freia.c.

{
  int count = 0;
  gen_context_recurse(s, &count, call_domain, gen_true2, sctc_call_rwt);
  // ??? I may have look into declarations? freia calls in declarations
  // are not really implemented yet.
  pips_user_warning("freia_cast switched to freia_copy: %d\n", count);
}

References call_domain, count, gen_context_recurse, gen_true2(), pips_user_warning, and sctc_call_rwt().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

update_written_variables()

static void update_written_variables ( set  written, statement  s  )

static

update the set of written variables, as seen from effects, with a statement this is really to rebuild a poor's man dependency graph in order to move some statements around...

Definition at line 421 of file freia.c.

{
  list cumu = effects_effects(load_cumulated_rw_effects(s));
  FOREACH(effect, e, cumu)
    if (effect_write_p(e))
      set_add_element(written, written, effect_variable(e));
  ifdebug(9)
    set_fprint(stderr, "written", written,
               (gen_string_func_t) entity_local_name);
}

References effect_variable, effect_write_p, effects_effects, entity_local_name(), FOREACH, ifdebug, load_cumulated_rw_effects(), set_add_element(), set_fprint(), and written.

Referenced by fsi_seq_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

fsi_number

hash_table fsi_number = NULL

static

Definition at line 679 of file freia.c.

Referenced by fsi_cmp(), and fsi_sort().