freia-utils.c File Reference

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

Include dependency graph for freia-utils.c:

Go to the source code of this file.

Data Structures
struct	occs_ctx
struct	related_ctx

Macros
#define	T   true
#define	F   false
#define	NO_POC   { { spoc_poc_unused, 0 }, { spoc_poc_unused, 0 } }
#define	NO_MES   { measure_none, measure_none }
#define	NOPE_SPOC   { spoc_nothing, NO_POC, alu_unused, NO_MES }
#define	NOPE_TRPX   { 0, 0, 0, 0, 0, 0, false, false, NULL }
#define	NOPE_OPCL   { F, F, NULL, NULL }
#define	NOPE_SIGMAC   { "Id", "nop", "width, height", F, 0 }
#define	NOPE_MPPA   {"MPPA_KERNEL_NOP"}
#define	NO_SPOC   { spoc_not_implemented, NO_POC, alu_unused, NO_MES }
#define	NO_TRPX   { 0, 0, 0, 0, 0, -1, false, false, NULL }
#define	NO_OPCL   { F, F, NULL, NULL }
#define	NO_SIGMAC   { "not_implemented", NULL, NULL, F, 0 }
#define	NO_MPPA   {"MPPA_KERNEL_NOP"}
#define	TRPX_OP(c, op)   { 0, 0, 0, 0, 0, c, true, false, "TERAPIX_UCODE_" op }
#define	TRPX_IO(c, op)   { 0, 0, 0, 0, 0, c, true, true, "TERAPIX_UCODE_" op }
#define	TRPX_NG(c, op)   { 1, 1, 1, 1, 0, c, false, false, "TERAPIX_UCODE_" op }
#define	TRPX_MS(m, c, op)   { 0, 0, 0, 0, m, c, true, false, "TERAPIX_UCODE_" op }
#define	OPCL(op)   { T, F, "PIXEL_" op, NULL }
#define	OPCLK(op, init)   { F, T, "PIXEL_" op, "PIXEL_" init }
#define	SGC_W(ag, pref)   { #ag, #pref, "width", T, 1 }
#define	SGC_WH(ag, pref)   { #ag, #pref, "width, height", F, 0 }
#define	MPPA(kernel)   {#kernel}
#define	TY_INT   "int32_t"
#define	TY_PIN   "int32_t *"
#define	TY_CIP   "const int32_t *"
#define	TY_UIN   "uint32_t"
#define	TY_PUI   "uint32_t *"
#define	NO_PARAM   { NULL, NULL, NULL }
#define	FREIA_AIPO_API_SIZE   (sizeof(*FREIA_AIPO_API)/sizeof(freia_api_t))
#define	E_WRITE(v)   (v)
#define	E_READ(v)   ((void*)(((_int)v)+1))

Functions
const freia_api_t *	hwac_freia_api (const char *function)
	freia-utils.c More...
int	hwac_freia_api_index (const string function)
	returns the index of the description of an AIPO function More...
const freia_api_t *	get_freia_api (int index)
const freia_api_t *	get_freia_api_vtx (dagvtx v)
static string	get_var (string prefix, int *params)
string	what_operation (const _int type)
string	what_operation_shape (const _int type)
	SPoC: set shape depending on hardware component used by vertex. More...
void	freia_spoc_set_operation (const freia_api_t *api, _int *type, _int *id)
	??? beurk: I keep the operation as two ints for code regeneration. More...
list	freia_get_params (const freia_api_t *api, list args)
	get freia further parameters, skipping image ones More...
list	freia_get_vertex_params (const dagvtx v)
expression	freia_get_nth_scalar_param (const dagvtx v, int n)
int	freia_max_pixel_value (void)
list	freia_extract_params (const int napi, list args, string_buffer head, string_buffer head2, hash_table params, int *nparams)
	returns an allocated expression list of the parameters only (i.e. More...
call	freia_ok (void)
	build all is well freia constant More...
bool	freia_assignment_p (const entity e)
	tell whether it is an assignment to ignore? More...
statement	freia_copy_image (const entity source, const entity target)
void	hwac_replace_statement (statement s, call newc, bool kill)
	replace statement contents with call to c, or continue if kill More...
void	hwac_kill_statement (statement s)
	remove contents of statement s. More...
bool	freia_image_variable_p (const entity var)
	rather approximative? More...
static entity	get_assigned_variable (const statement s)
	for "ret = freia_aipo_*()": return the 'ret' variable... More...
bool	entity_freia_api_p (const entity f)
	returns whether the entity is a freia API (AIPO) function. More...
bool	freia_statement_aipo_call_p (const statement s)
	returns whether the statement is a FREIA call. More...
static void	set_add_scalars (set s, const statement stat, const bool written)
	append simple scalar entities with written/read effects to s scalars assigned to are ignored (return status). More...
static bool	real_freia_scalar_rw_dep (const statement s, const statement t, list *vars)
	is there a simple scalar (no image) rw dependency from s to t? WW deps are ignored... More...
void	freia_init_dep_cache (void)
void	freia_close_dep_cache (void)
bool	freia_scalar_rw_dep (const statement s, const statement t, list *vars)
static bool	lexpression_equal_p (const list l1, const list l2)
call	freia_statement_to_call (const statement s)
	return the actual function call from a statement, dealing with assign and returns... More...
static bool	is_freia_this_call (const statement s, const string fname)
bool	is_freia_alloc (const statement s)
bool	is_freia_dealloc (const statement s)
bool	same_constant_parameters (const dagvtx v1, const dagvtx v2)
	tell whether v1 and v2 point to statements with the same parameters. More...
entity	freia_create_helper_function (const string function_name, list lparams)
int	freia_substitute_by_helper_call (dag d, set global_remainings, set remainings, list ls, const string function_name, list lparams, set helpers, int preceeding)
	substitute those statement in ls that are in dag d and accelerated by a call to function_name(lparams) also update sets of remainings and global_remainings More...
static statement	find_aipo_statement (list ls, bool before)
void	freia_insert_added_stats (list ls, list stats, bool before)
	insert statements to actual code sequence in "ls" BEWARE that ls is assumed to be in reverse order... More...
void	freia_add_image_arguments (list limg, list *lparams)
	prepend limg images in front of the argument list limg is consummed by the operation. More...
static int	reference_argument_number (const reference r, const list le)
	return the argument number, starting from 1, of this reference or 0 if not found. More...
static bool	reference_written_p (const reference r, const hash_table signatures)
	tell about the image effect. More...
static bool	check_ref (reference r, occs_ctx *ctx)
	hack to help replace use-def chains which did not work initially with C. More...
static void	check_ref2 (reference r, occs_ctx *ctx)
static bool	check_stmt (statement s, occs_ctx *ctx)
hash_table	freia_build_image_occurrences (statement s, set image_occs_stats, hash_table image_stats, const hash_table signatures)
void	freia_clean_image_occurrences (hash_table occs)
	cleanup occurrence data structure More...
bool	freia_aipo_spoc_implemented (const freia_api_t *api)
	whether api available with SPoC More...
bool	freia_aipo_terapix_implemented (const freia_api_t *api)
	whether api available with Ter@pix More...
bool	freia_convolution_p (dagvtx v)
	is it the convolution special case? More...
bool	freia_convolution_width_height (dagvtx v, _int *pw, _int *ph, bool check)
	get width & height of convolution More...
static void	clean_stats_to_image (hash_table s2i)
static statement	image_free (entity v)
	generate statement: "freia_free(v);" More...
static bool	related_images_p (const entity img1, const entity img2, const hash_table new_images)
	is there an effect to this image or related images in the statement? More...
static bool	related_effect (statement s, struct related_ctx *ctx)
static bool	some_related_image_effect (statement s, entity img, hash_table new_images, hash_table image_stats, bool write_only)
static bool	only_minor_statements_in_between (entity image, hash_table new_images, hash_table image_stats, list ls, statement s1, list l2, set image_occurences)
	tell whether there is no image processing statements between s1 and l2 More...
list	freia_allocate_new_images_if_needed (list ls, list images, const hash_table occs, const hash_table init, const hash_table signatures)
	insert image allocation if needed, for intermediate image inserted before if an image is used only twice, then it is switched back to the initial one More...
int	freia_aipo_count (dag d, int *pa, int *pc)
static void	oi_call_rwt (call c, set images)
static void	oi_stmt_rwt (statement s, set images)
set	freia_compute_output_images (entity module, statement s)
set	freia_compute_current_output_images (void)
static string	stat_nb (statement s)
void	freia_migrate_statements (sequence sq, const set stats, const set before)
static bool	freia_extract_kernel (expression e, bool strict, intptr_t *k00, intptr_t *k10, intptr_t *k20, intptr_t *k01, intptr_t *k11, intptr_t *k21, intptr_t *k02, intptr_t *k12, intptr_t *k22)
	extract values from a kernel definition return 9 values, expected to be 0/1 elsewhere... More...
bool	freia_extract_kernel_vtx (dagvtx v, bool strict, intptr_t *k00, intptr_t *k10, intptr_t *k20, intptr_t *k01, intptr_t *k11, intptr_t *k21, intptr_t *k02, intptr_t *k12, intptr_t *k22)
	vertex-based version More...
string	helper_file_name (string func_name, string suffix)
	return malloc'ed "foo.database/Src/%{module}_helper_functions.c" should it depend on the target? no, because we could mix targets? More...

Variables
static const freia_api_t	FREIA_AIPO_API []
	!!! there are some underlying assumptions when using this structure: only one of ALU/POC/MES is used per AIPO. More...
static hash_table	dep_cache = NULL

Macro Definition Documentation

E_READ

#define E_READ

(

v

)

((void*)(((_int)v)+1))

Definition at line 1248 of file freia-utils.c.

E_WRITE

#define E_WRITE

(

v

)

(v)

Definition at line 1247 of file freia-utils.c.

F

#define F   false

Definition at line 51 of file freia-utils.c.

FREIA_AIPO_API_SIZE

#define FREIA_AIPO_API_SIZE   (sizeof(*FREIA_AIPO_API)/sizeof(freia_api_t))

Definition at line 450 of file freia-utils.c.

MPPA

#define MPPA

(

kernel

)

{#kernel}

Definition at line 83 of file freia-utils.c.

NO_MES

#define NO_MES   { measure_none, measure_none }

Definition at line 54 of file freia-utils.c.

NO_MPPA

#define NO_MPPA   {"MPPA_KERNEL_NOP"}

Definition at line 68 of file freia-utils.c.

NO_OPCL

#define NO_OPCL   { F, F, NULL, NULL }

Definition at line 66 of file freia-utils.c.

NO_PARAM

#define NO_PARAM   { NULL, NULL, NULL }

Definition at line 92 of file freia-utils.c.

NO_POC

#define NO_POC   { { spoc_poc_unused, 0 }, { spoc_poc_unused, 0 } }

Definition at line 53 of file freia-utils.c.

NO_SIGMAC

#define NO_SIGMAC   { "not_implemented", NULL, NULL, F, 0 }

Definition at line 67 of file freia-utils.c.

NO_SPOC

#define NO_SPOC   { spoc_not_implemented, NO_POC, alu_unused, NO_MES }

Definition at line 64 of file freia-utils.c.

NO_TRPX

#define NO_TRPX   { 0, 0, 0, 0, 0, -1, false, false, NULL }

Definition at line 65 of file freia-utils.c.

NOPE_MPPA

#define NOPE_MPPA   {"MPPA_KERNEL_NOP"}

Definition at line 61 of file freia-utils.c.

NOPE_OPCL

#define NOPE_OPCL   { F, F, NULL, NULL }

Definition at line 59 of file freia-utils.c.

NOPE_SIGMAC

#define NOPE_SIGMAC   { "Id", "nop", "width, height", F, 0 }

Definition at line 60 of file freia-utils.c.

NOPE_SPOC

#define NOPE_SPOC   { spoc_nothing, NO_POC, alu_unused, NO_MES }

Definition at line 57 of file freia-utils.c.

NOPE_TRPX

#define NOPE_TRPX   { 0, 0, 0, 0, 0, 0, false, false, NULL }

Definition at line 58 of file freia-utils.c.

OPCL

#define OPCL

(

op

)

{ T, F, "PIXEL_" op, NULL }

Definition at line 77 of file freia-utils.c.

OPCLK

#define OPCLK	(		op,
			init
	)		{ F, T, "PIXEL_" op, "PIXEL_" init }

Definition at line 78 of file freia-utils.c.

SGC_W

#define SGC_W	(		ag,
			pref
	)		{ #ag, #pref, "width", T, 1 }

Definition at line 80 of file freia-utils.c.

SGC_WH

#define SGC_WH	(		ag,
			pref
	)		{ #ag, #pref, "width, height", F, 0 }

Definition at line 81 of file freia-utils.c.

T

#define T   true

Definition at line 50 of file freia-utils.c.

TRPX_IO

#define TRPX_IO	(		c,
			op
	)		{ 0, 0, 0, 0, 0, c, true, true, "TERAPIX_UCODE_" op }

Definition at line 71 of file freia-utils.c.

TRPX_MS

#define TRPX_MS	(		m,
			c,
			op
	)		{ 0, 0, 0, 0, m, c, true, false, "TERAPIX_UCODE_" op }

Definition at line 75 of file freia-utils.c.

TRPX_NG

#define TRPX_NG	(		c,
			op
	)		{ 1, 1, 1, 1, 0, c, false, false, "TERAPIX_UCODE_" op }

Definition at line 72 of file freia-utils.c.

TRPX_OP

#define TRPX_OP	(		c,
			op
	)		{ 0, 0, 0, 0, 0, c, true, false, "TERAPIX_UCODE_" op }

Definition at line 70 of file freia-utils.c.

TY_CIP

#define TY_CIP   "const int32_t *"

Definition at line 88 of file freia-utils.c.

TY_INT

#define TY_INT   "int32_t"

Definition at line 86 of file freia-utils.c.

TY_PIN

#define TY_PIN   "int32_t *"

Definition at line 87 of file freia-utils.c.

TY_PUI

#define TY_PUI   "uint32_t *"

Definition at line 90 of file freia-utils.c.

TY_UIN

#define TY_UIN   "uint32_t"

Definition at line 89 of file freia-utils.c.

Function Documentation

check_ref()

static bool check_ref ( reference  r, occs_ctx *  ctx  )

static

hack to help replace use-def chains which did not work initially with C.

occurrences is: <image entity> -> { set of statements } this is really a ugly hack, sorry! ??? I should also consider declarations, but as they should only contain image allocations so there should be no problem.

Definition at line 1328 of file freia-utils.c.

{
  entity v = reference_variable(r);
  if (freia_image_variable_p(v))
  {
    // ensure that target set exists
    if (!hash_defined_p(ctx->occs, v))
    {
      hash_put(ctx->occs, E_WRITE(v), set_make(set_pointer));
      hash_put(ctx->occs, E_READ(v), set_make(set_pointer));
    }
    bool written = reference_written_p(r, ctx->signatures);
    set stats = (set) hash_get(ctx->occs, written? E_WRITE(v): E_READ(v));
    // get containing statement
    statement up = ctx->enclosing? ctx->enclosing:
      (statement) gen_get_ancestor(statement_domain, r);
    // which MUST exist?
    pips_assert("some containing statement", up);
    if (ctx->image_stats) {
      set sop = (set) hash_get(ctx->image_stats,
                               written? E_WRITE(up): E_READ(up));
      set_add_element(sop, sop, (void*) v);
    }
    // store result
    set_add_element(stats, stats, (void*) up);
    if (ctx->image_occs_stats)
      set_add_element(ctx->image_occs_stats, ctx->image_occs_stats, up);
 
    pips_debug(9, "entity %s in statement %"_intFMT"\n",
               entity_name(v), statement_number(up));
  }
  return true;
}

References _intFMT, E_READ, E_WRITE, occs_ctx::enclosing, entity_name, freia_image_variable_p(), gen_get_ancestor(), hash_defined_p(), hash_get(), hash_put(), occs_ctx::image_occs_stats, occs_ctx::image_stats, occs_ctx::occs, pips_assert, pips_debug, reference_variable, reference_written_p(), set_add_element(), set_make(), set_pointer, occs_ctx::signatures, statement_domain, statement_number, and written.

Referenced by check_ref2(), and freia_build_image_occurrences().

Here is the call graph for this function:

Here is the caller graph for this function:

check_ref2()

static void check_ref2 ( reference  r, occs_ctx *  ctx  )

static

Definition at line 1362 of file freia-utils.c.

{
  (void) check_ref(r, ctx);
}

References check_ref().

Referenced by check_stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

check_stmt()

static bool check_stmt ( statement  s, occs_ctx *  ctx  )

static

Definition at line 1367 of file freia-utils.c.

{
  // ensure existing set
  if (ctx->image_stats) {
    pips_debug(8, "creating for statement %"_intFMT"\n",
               statement_number(s));
    hash_put(ctx->image_stats, E_WRITE(s), set_make(set_pointer));
    hash_put(ctx->image_stats, E_READ(s), set_make(set_pointer));
  }
  ctx->enclosing = s;
  FOREACH(entity, var, statement_declarations(s))
    gen_context_recurse(entity_initial(var), ctx,
                        reference_domain, gen_true2, check_ref2);
  ctx->enclosing = NULL;
  return true;
}

References _intFMT, check_ref2(), E_READ, E_WRITE, occs_ctx::enclosing, entity_initial, FOREACH, gen_context_recurse, gen_true2(), hash_put(), occs_ctx::image_stats, pips_debug, reference_domain, set_make(), set_pointer, statement_declarations, and statement_number.

Referenced by freia_build_image_occurrences().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_stats_to_image()

static void clean_stats_to_image ( hash_table  s2i )

static

Definition at line 1463 of file freia-utils.c.

{
  HASH_FOREACH(statement, st, set, imgs, s2i)
    set_free(imgs);
  hash_table_free(s2i);
}

References HASH_FOREACH, hash_table_free(), and set_free().

Referenced by freia_allocate_new_images_if_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_freia_api_p()

bool entity_freia_api_p

(

const entity

f

)

returns whether the entity is a freia API (AIPO) function.

Definition at line 806 of file freia-utils.c.

{
  // very partial...
  return strncmp(entity_local_name(f), AIPO, strlen(AIPO))==0;
}

References AIPO, entity_local_name(), and f().

Referenced by dag_append_freia_call(), fcs_call_flt(), and freia_statement_aipo_call_p().

Here is the call graph for this function:

Here is the caller graph for this function:

find_aipo_statement()

static statement find_aipo_statement ( list  ls, bool  before  )

static

Definition at line 1147 of file freia-utils.c.

{
  pips_assert("some statements", ls);
  pips_debug(8, "choosing among %d statements\n", (int) gen_length(ls));
 
  statement found = NULL;
 
  FOREACH(statement, s, ls)
  {
    pips_debug(8, "stmt %" _intFMT "\n", statement_number(s));
    if (before)
    {
      if (!found || statement_number(found)>statement_number(s))
        found = s;
    }
    else // after
    {
      if (!found || statement_number(found)<statement_number(s))
        found = s;
    }
  }
 
  // ??? au pif
  if (!found && ls)
  {
    pips_debug(8, "no aipo call found... backup plan?\n");
    if (before)
      found = STATEMENT(CAR(gen_last(ls))); // list is reversed...
    else
      found = STATEMENT(CAR(ls));
  }
 
  return found;
}

References _intFMT, CAR, FOREACH, gen_last(), gen_length(), pips_assert, pips_debug, STATEMENT, and statement_number.

Referenced by freia_insert_added_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_add_image_arguments()

void freia_add_image_arguments	(	list	limg,
		list *	lparams
	)

prepend limg images in front of the argument list limg is consummed by the operation.

Parameters

limg	img
lparams	params

Definition at line 1233 of file freia-utils.c.

{
  list largs = NIL;
  limg = gen_nreverse(limg);
  FOREACH(entity, e, limg)
    largs = CONS(expression, entity_to_expression(e), largs);
  gen_free_list(limg), limg = NIL;
  *lparams = gen_nconc(largs, *lparams);
}

References CONS, entity_to_expression(), FOREACH, gen_free_list(), gen_nconc(), gen_nreverse(), lparams, and NIL.

Referenced by freia_spoc_pipeline(), freia_terapix_call(), and opencl_compile_mergeable_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_aipo_count()

int freia_aipo_count	(	dag	d,
		int *	pa,
		int *	pc
	)

Returns

the number for FREIA AIPO ops in dag

Parameters

pa	a
pc	c

Definition at line 1823 of file freia-utils.c.

{
  int aipos = 0, copies = 0;
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    string op = dagvtx_function_name(v);
    if (strncmp(op, AIPO, strlen(AIPO))==0) aipos++;
    // handle exceptions afterwards
    if (same_string_p(op, AIPO "copy")) copies++, aipos--;
    else if (same_string_p(op, AIPO "cast")) copies++, aipos--;
    else if (same_string_p(op, AIPO "scalar_copy")) aipos--;
  }
  *pa = aipos, *pc = copies;
  return aipos+copies;
}

References AIPO, dag_vertices, dagvtx_function_name(), FOREACH, and same_string_p.

Referenced by freia_opencl_compile_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_aipo_spoc_implemented()

bool freia_aipo_spoc_implemented

(

const freia_api_t *

api

)

whether api available with SPoC

Parameters

api

pi

Definition at line 1418 of file freia-utils.c.

{
  pips_assert("some api", api!=NULL);
  return api->spoc.used!=spoc_not_implemented;
}

References pips_assert, freia_api_t::spoc, spoc_not_implemented, and spoc_hw_t::used.

freia_aipo_terapix_implemented()

bool freia_aipo_terapix_implemented

(

const freia_api_t *

api

)

whether api available with Ter@pix

Parameters

api

pi

Definition at line 1426 of file freia-utils.c.

{
  pips_assert("some api", api!=NULL);
  // some special cases are handled manually
  if (same_string_p(api->function_name, "undefined") ||
      // this one is inserted to deal with replicated measures
      same_string_p(api->function_name, AIPO "scalar_copy"))
    return true;
  return api->terapix.cost!=-1;
}

References AIPO, terapix_hw_t::cost, freia_api_t::function_name, pips_assert, same_string_p, and freia_api_t::terapix.

Referenced by dagvtx_terapix_priority().

Here is the caller graph for this function:

freia_allocate_new_images_if_needed()

list freia_allocate_new_images_if_needed	(	list	ls,
		list	images,
		const hash_table	occs,
		const hash_table	init,
		const hash_table	signatures
	)

insert image allocation if needed, for intermediate image inserted before if an image is used only twice, then it is switched back to the initial one

This could/should be improved:

• temporary images kept could be reused if possible, instead of new ones
• not sure about the condition to move back to the initial image

Parameters

ls	list of statements to consider
images	list of entities to check and maybe allocate
init	new image -> initial image
signatures	helper -> _int # written args ahead (may be NULL)

Returns

list of actually allocated images

Parameters

ls	s
images	mages
occs	ccs
init	nit
signatures	ignatures

Definition at line 1650 of file freia-utils.c.

{
  // check for used images
  set img_stats = set_make(set_pointer);
  hash_table image_stats_detailed = hash_table_make(hash_pointer, 0);
  sequence sq = make_sequence(ls);
  hash_table newoccs =
    freia_build_image_occurrences((statement) sq, img_stats,
                                  image_stats_detailed, signatures);
  sequence_statements(sq) = NIL;
  free_sequence(sq);
 
  list allocated = NIL;
  FOREACH(entity, v, images)
  {
    if (!hash_defined_p(newoccs, v))
      // no written occurences, the image is not kept
      continue;
 
    if (get_bool_property("FREIA_REUSE_INITIAL_IMAGES"))
    {
      set where_write = (set) hash_get(newoccs, E_WRITE(v));
      set where_read = (set) hash_get(newoccs, E_READ(v));
      int nw = set_size(where_write), nr = set_size(where_read);
 
      pips_debug(6, "image %s used %d+%d statements\n", entity_name(v), nw, nr);
 
      // ??? should be used once only in the statement if written!
      // how to I know about W/R for helper functions?
      // its siblings should also be take into account
 
      // n>1 ??
      // if used only twice, substitude back to initial variable???
      // well, it may depends whether the the initial variable is used?
      // there is possibly something intelligent to do here, but it should
      // be checked carefully...
      if (nw==1 && nr>=1 && hash_defined_p(init, v))
      {
        entity old = (entity) hash_get(init, v);
 
        // get statements
        list l1 = set_to_list(where_write), l2 = set_to_list(where_read);
        statement s1 = STATEMENT(CAR(l1));
        gen_free_list(l1), l1 = NIL;
 
        // does not interact with possibly used old
        // if we could differentiate read & write, we could do better,
        // but the information is not currently available.
        bool skip = false;
        if (hash_defined_p(newoccs, old))
        {
          set old_write = (set) hash_get(newoccs, E_WRITE(old));
          set old_read = (set) hash_get(newoccs, E_READ(old));
          if (set_belong_p(old_write, s1))
            skip = true;
          else
          {
            FOREACH(statement, s2, l2)
              if (set_belong_p(old_read, s2))
                skip = true;
          }
          // note that we can handle a read in s1 and a write in s2
        }
 
        pips_debug(7, "testing for %s -> %s: %s\n",
                   entity_local_name(v), entity_local_name(old),
                   skip?"skip":"ok");
 
        // do we want to switch back?
        if (!skip &&
            only_minor_statements_in_between(v, init, image_stats_detailed,
                                             ls, s1, l2, img_stats))
        {
          // yes, they are successive, just remove?? Am I that sure???
          // ??? hmmm, maybe we could have :
          //   X   = stuff(...)
          //   X_1 = stuff(...)
          //   ... = stuff(X_1, ...)
          //   ... = stuff(X...)
          // where X_1 -> X is just a bad idea because it overwrites X?
          // I'm not sure this can happen with AIPO, as X would be X_2
          // and will not be changed?
          pips_debug(7, "substituting back %s by %s\n",
                     entity_local_name(v), entity_local_name(old));
 
          // we can perform any substitution here
          // note that it may be generated helper functions
          freia_switch_image_in_statement(s1, v, old, true);
          FOREACH(statement, s2, l2)
            freia_switch_image_in_statement(s2, v, old, false);
 
          // create/update uses of "old" to avoid interactions
          if (!hash_defined_p(newoccs, old))
          {
            hash_put(newoccs, E_WRITE(old), set_make(set_pointer));
            hash_put(newoccs, E_READ(old), set_make(set_pointer));
          }
          set old_write = (set) hash_get(newoccs, E_WRITE(old));
          set_add_element(old_write, old_write, s1);
          set old_read = (set) hash_get(newoccs, E_READ(old));
          FOREACH(statement, s2, l2)
            set_add_element(old_read, old_read, s2);
        }
        else
          allocated = CONS(entity, v, allocated);
      }
      else
        allocated = CONS(entity, v, allocated);
    }
    else
      allocated = CONS(entity, v, allocated);
  }
 
  clean_stats_to_image(image_stats_detailed);
  freia_clean_image_occurrences(newoccs);
  set_free(img_stats);
 
  // allocate those which are finally used
  if (allocated)
  {
    pips_assert("some statements", ls!=NIL);
    statement first = STATEMENT(CAR(ls));
    statement last = STATEMENT(CAR(gen_last(ls)));
    pips_assert("at least two statements", first!=last);
 
    // insert free_image(v)...
    // should insert image allocation statement as the same time
    // currently the allocation/deallocation may not be in the same scope!!!
    FOREACH(entity, v, images)
    {
      pips_debug(7, "allocating image %s\n", entity_name(v));
      // add_declaration_statement(first, v); // NO, returned
      // insert_statement(first, image_alloc(v), true); // NO, init
      // ??? deallocation should be at end of allocation block...
      entity model = (entity) hash_get(init, v);
      bool before = false;
      // find free_image(model) in the code
      statement fs = freia_memory_management_statement(model, occs, false);
      if (!fs)
      {
        pips_user_warning("not quite sure where to put %s deallocation\n",
                          entity_name(v));
        // hmmm... try at the program level
        statement ms = get_current_module_statement();
        if (statement_sequence_p(ms))
        {
          fs = STATEMENT(
            CAR(gen_last(sequence_statements(statement_sequence(ms)))));
          // hmmm... does not seem to work properly
          //if (statement_call_p(s) &&
          // ENTITY_C_RETURN_P(call_function(statement_call(s))))
          before = true;
        }
      }
      insert_statement(fs? fs: last, image_free(v), before);
    }
  }
 
  return allocated;
}

References CAR, clean_stats_to_image(), CONS, E_READ, E_WRITE, entity_local_name(), entity_name, FOREACH, free_sequence(), freia_build_image_occurrences(), freia_clean_image_occurrences(), freia_memory_management_statement(), freia_switch_image_in_statement(), gen_free_list(), gen_last(), get_bool_property(), get_current_module_statement(), hash_defined_p(), hash_get(), hash_pointer, hash_put(), hash_table_make(), image_free(), init, insert_statement(), make_sequence(), NIL, only_minor_statements_in_between(), pips_assert, pips_debug, pips_user_warning, s1, sequence_statements, set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, set_size(), set_to_list(), STATEMENT, statement_sequence(), and statement_sequence_p().

Referenced by freia_aipo_compile_calls(), freia_mppa_compile_calls(), freia_opencl_compile_calls(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_assignment_p()

bool freia_assignment_p

(

const entity

e

)

tell whether it is an assignment to ignore?

Definition at line 703 of file freia-utils.c.

{
  return ENTITY_ASSIGN_P(e) || ENTITY_BITWISE_OR_UPDATE_P(e);
}

References ENTITY_ASSIGN_P, and ENTITY_BITWISE_OR_UPDATE_P.

Referenced by fcs_call_flt(), freia_statement_aipo_call_p(), freia_statement_to_call(), get_assigned_variable(), and hwac_replace_statement().

Here is the caller graph for this function:

freia_build_image_occurrences()

hash_table freia_build_image_occurrences	(	statement	s,
		set	image_occs_stats,
		hash_table	image_stats,
		const hash_table	signatures
	)

Parameters

image_occs_stats	set of statements with image occurences (may be NULL)
signatures	helper entity -> (_int) # out args

Returns

build occurrence hash table: { entity -> set of statements }

Parameters

image_occs_stats	mage_occs_stats
image_stats	mage_stats
signatures	ignatures

Definition at line 1388 of file freia-utils.c.

{
  pips_debug(7, "entering\n");
  occs_ctx ctx = { hash_table_make(hash_pointer, 0), NULL,
                   image_occs_stats, image_stats, signatures };
  gen_context_multi_recurse(s, &ctx,
                            statement_domain, check_stmt, gen_null,
                            reference_domain, check_ref, gen_null,
                            NULL);
  pips_debug(7, "done\n");
  return ctx.occs;
}

References check_ref(), check_stmt(), gen_context_multi_recurse(), gen_null(), hash_pointer, hash_table_make(), occs_ctx::occs, pips_debug, reference_domain, and statement_domain.

Referenced by freia_allocate_new_images_if_needed(), and freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_clean_image_occurrences()

void freia_clean_image_occurrences

(

hash_table

occs

)

cleanup occurrence data structure

Parameters

occs

ccs

Definition at line 1407 of file freia-utils.c.

{
  HASH_FOREACH(entity, v, set, s, occs)
    set_free(s);
  hash_table_free(occs);
}

References HASH_FOREACH, hash_table_free(), and set_free().

Referenced by freia_allocate_new_images_if_needed(), and freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_close_dep_cache()

void freia_close_dep_cache

(

void

)

Definition at line 915 of file freia-utils.c.

{
  pips_assert("dep_cache is not NULL", dep_cache);
 
  HASH_FOREACH(statement, s1, hash_table, h, dep_cache) {
    HASH_FOREACH(statement, s2, list, l, h)
      if (l) gen_free_list(l);
    hash_table_free(h);
  }
 
  hash_table_free(dep_cache), dep_cache = NULL;
}

References dep_cache, gen_free_list(), HASH_FOREACH, hash_table_free(), pips_assert, and s1.

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_compute_current_output_images()

set freia_compute_current_output_images

(

void

)

Definition at line 1885 of file freia-utils.c.

{
  return freia_compute_output_images(get_current_module_entity(),
                                     get_current_module_statement());
}

References freia_compute_output_images(), get_current_module_entity(), and get_current_module_statement().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_compute_output_images()

set freia_compute_output_images	(	entity	module,
		statement	s
	)

Returns

the set of images which are output somehow this is a little bit simplistic... read output effects of statement?

Parameters

module

odule

Definition at line 1866 of file freia-utils.c.

{
  set images = set_make(set_pointer);
 
  // image formal parameters
  FOREACH(entity, var, module_functional_parameters(module))
  {
    if (freia_image_variable_p(var))
      set_add_element(images, images, var);
  }
 
  // some image uses in the code
  gen_context_multi_recurse(s, images,
                            statement_domain, gen_true, oi_stmt_rwt,
                            call_domain, gen_true, oi_call_rwt,
                            NULL);
  return images;
}

References call_domain, FOREACH, freia_image_variable_p(), gen_context_multi_recurse(), gen_true(), module, module_functional_parameters, oi_call_rwt(), oi_stmt_rwt(), set_add_element(), set_make(), set_pointer, and statement_domain.

Referenced by freia_compute_current_output_images().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_convolution_p()

bool freia_convolution_p

(

dagvtx

v

)

is it the convolution special case?

Definition at line 1441 of file freia-utils.c.

{
  return same_string_p(dagvtx_operation(v), "convolution");
}

References dagvtx_operation(), and same_string_p.

Referenced by dag_terapix_measures(), sc_inst(), sigmac_params_decl(), terapix_gram_management(), terapix_macro_code(), and update_erosions().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_convolution_width_height()

bool freia_convolution_width_height	(	dagvtx	v,
		_int *	pw,
		_int *	ph,
		bool	check
	)

get width & height of convolution

Returns

whether they could be extracted

Parameters

pw	w
ph	h
check	heck

Definition at line 1449 of file freia-utils.c.

{
  // pips_assert("vertex is convolution", ...)
  list largs = freia_get_vertex_params(v);
  if (check) pips_assert("3 args to convolution", gen_length(largs)==3);
  bool bw = expression_integer_value(EXPRESSION(CAR(CDR(largs))), pw);
  if (check) pips_assert("constant convolution width", bw);
  if (check) pips_assert("odd convolution width", ((*pw)%2)==1);
  bool bh = expression_integer_value(EXPRESSION(CAR(CDR(CDR(largs)))), ph);
  if (check) pips_assert("constant convolution height", bh);
  if (check) pips_assert("odd convolution height", ((*ph)%2)==1);
  return bw && bh;
}

References CAR, CDR, EXPRESSION, expression_integer_value(), freia_get_vertex_params(), gen_length(), and pips_assert.

Referenced by dag_terapix_measures(), terapix_gram_management(), terapix_macro_code(), and update_erosions().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_copy_image()

statement freia_copy_image	(	const entity	source,
		const entity	target
	)

Returns

"freia_aipo_copy(target, source);"

Parameters

source	ource
target	arget

Definition at line 710 of file freia-utils.c.

{
  return call_to_statement(
    make_call(local_name_to_top_level_entity(AIPO "copy"),
              CONS(expression, entity_to_expression(target),
                   CONS(expression, entity_to_expression(source), NIL))));
}

References AIPO, call_to_statement, CONS, entity_to_expression(), local_name_to_top_level_entity(), make_call(), and NIL.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_create_helper_function()

entity freia_create_helper_function	(	const string	function_name,
		list	lparams
	)

Parameters

function_name	unction_name
lparams	params

Definition at line 1030 of file freia-utils.c.

{
  // build helper entity
  entity example = local_name_to_top_level_entity("freia_aipo_add");
  pips_assert("example is a function", entity_function_p(example));
  entity helper = make_empty_function(function_name,
        copy_type(functional_result(type_functional(entity_type(example)))),
                                      make_language_c());
 
  // update type of parameters
  list larg_params = NIL;
  FOREACH(expression, e, lparams)
  {
    debug_on("RI_UTILS_DEBUG_LEVEL");
    type t = expression_to_user_type(e);
    debug_off();
    larg_params = CONS(parameter,
                       make_parameter(t,
                                      make_mode_value(),
                                      make_dummy_unknown()),
                       larg_params);
  }
  larg_params = gen_nreverse(larg_params);
  module_functional_parameters(helper) = larg_params;
 
  return helper;
}

References CONS, copy_type(), debug_off, debug_on, entity_function_p(), entity_type, expression_to_user_type(), FOREACH, functional_result, gen_nreverse(), local_name_to_top_level_entity(), lparams, make_dummy_unknown(), make_empty_function(), make_language_c(), make_mode_value(), make_parameter(), module_functional_parameters, NIL, pips_assert, and type_functional.

Referenced by freia_substitute_by_helper_call(), mppa_call_helper(), opencl_generate_special_kernel_ops(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_extract_kernel()

static bool freia_extract_kernel ( expression  e, bool  strict, intptr_t *  k00, intptr_t *  k10, intptr_t *  k20, intptr_t *  k01, intptr_t *  k11, intptr_t *  k21, intptr_t *  k02, intptr_t *  k12, intptr_t *  k22  )

static

extract values from a kernel definition return 9 values, expected to be 0/1 elsewhere...

Returns

whether it succeeded

Definition at line 1957 of file freia-utils.c.

{
  // set default value anyway
  *k00 = 1, *k10 = 1, *k20 = 1,
  *k01 = 1, *k11 = 1, *k21 = 1,
  *k02 = 1, *k12 = 1, *k22 = 1;
 
  // analyse kernel
  if (!expression_reference_p(e)) return !strict;
  entity var = expression_variable(e);
  // ??? should check const...
  value val = entity_initial(var);
  if (!value_expression_p(val)) return !strict;
  expression ival = value_expression(val);
  if (!brace_expression_p(ival)) return !strict;
  list iargs = call_arguments(syntax_call(expression_syntax(ival)));
  pips_assert("must be a 3x3 kernel...", gen_length(iargs)==9);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k00) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k10) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k20) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k01) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k11) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k21) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k02) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k12) && strict)
    return false;
  iargs = CDR(iargs);
  if (!expression_integer_value(EXPRESSION(CAR(iargs)), k22) && strict)
    return false;
  iargs = CDR(iargs);
  pips_assert("end of list reached", iargs==NIL);
  return true;
}

References brace_expression_p(), call_arguments, CAR, CDR, entity_initial, EXPRESSION, expression_integer_value(), expression_reference_p(), expression_syntax, expression_variable(), gen_length(), NIL, pips_assert, syntax_call, value_expression, and value_expression_p.

Referenced by freia_extract_kernel_vtx().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_extract_kernel_vtx()

bool freia_extract_kernel_vtx	(	dagvtx	v,
		bool	strict,
		intptr_t *	k00,
		intptr_t *	k10,
		intptr_t *	k20,
		intptr_t *	k01,
		intptr_t *	k11,
		intptr_t *	k21,
		intptr_t *	k02,
		intptr_t *	k12,
		intptr_t *	k22
	)

vertex-based version

Parameters

strict	trict
k00	00
k10	10
k20	20
k01	01
k11	11
k21	21
k02	02
k12	12
k22	22

Definition at line 2012 of file freia-utils.c.

{
  list largs = freia_get_vertex_params(v);
  // for convolution there is one kernel & two args
  // pips_assert("one kernel", gen_length(largs)==1);
  expression e = EXPRESSION(CAR(largs));
  return freia_extract_kernel(e, strict, k00, k10, k20,
                              k01, k11, k21, k02, k12, k22);
}

References CAR, EXPRESSION, freia_extract_kernel(), and freia_get_vertex_params().

Referenced by constant_image_p(), copy_image_p(), dagvtx_constant_kernel_p(), erosion_optimization(), mppa_compile_dag(), mppa_helper_args_params(), opencl_compile_mergeable_dag(), opencl_generate_special_kernel_ops(), opencl_merge_and_compile(), sc_kernel_compute_loop(), and sc_print_kernel().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_extract_params()

list freia_extract_params	(	const int	napi,
		list	args,
		string_buffer	head,
		string_buffer	head2,
		hash_table	params,
		int *	nparams
	)

returns an allocated expression list of the parameters only (i.e.

do not include the input & output images). params maps variables (if so) to already present parameters names. the extraction function allocs new parameter names if necessary. of expression

Parameters

napi	api
args	rgs
head	ead
head2	ead2
params	arams
nparams	params

Definition at line 612 of file freia-utils.c.

{
  const freia_api_t * api = get_freia_api(napi);
  args = freia_get_params(api, args);
  list res = NIL;
  bool merge = get_bool_property("FREIA_MERGE_ARGUMENTS");
 
  // important shortcut, taken when ops are switched to "copy" for
  // some reason, then the next assert would not be consistent.
  if (api->arg_misc_in==0 && api->arg_misc_out==0)
    return NIL;
 
  pips_assert("number of arguments is okay",
              gen_length(args)==api->arg_misc_in+api->arg_misc_out);
 
  for (unsigned int i = 0; i<api->arg_misc_in; i++)
  {
    expression e = EXPRESSION(CAR(args));
    args = CDR(args);
 
    if (params)
    {
      // ??? if the expression is a constant,
      // the parameter could be skipped as well?
      entity var = expression_to_entity(e);
      if (merge && !entity_undefined_p(var) && entity_variable_p(var))
      {
        if (!hash_defined_p(params, var))
        {
          // choose new name
          string name = get_var("pi", nparams);
          if (head) sb_cat(head, ",\n  ", api->arg_in_types[i], " ", name);
          if (head2) sb_cat(head2, ", ", api->arg_in_types[i], " ", name);
          hash_put(params, e, name);
          res = CONS(expression, copy_expression(e), res);
          // keep record for the *variable* as well...
          hash_put(params, var, name);
        }
        else
        {
          // skip argument, just record its where it is found
          hash_put(params, e, hash_get(params, var));
        }
      }
      else
      {
        // append and record new parameter
        string name = get_var("pi", nparams);
        if (head) sb_cat(head, ",\n  ", api->arg_in_types[i], " ", name);
        if (head2) sb_cat(head2, ", ", api->arg_in_types[i], " ", name);
        hash_put(params, e, name);
        res = CONS(expression, copy_expression(e), res);
      }
    }
    else
      res = CONS(expression, copy_expression(e), res);
  }
 
  for (unsigned int i = 0; i<api->arg_misc_out; i++)
  {
    expression e = EXPRESSION(CAR(args));
    args = CDR(args);
    string name = get_var("po", nparams);
    if (head) sb_cat(head, ",\n  ", api->arg_out_types[i], " ", name);
    if (head2) sb_cat(head2, ", ", api->arg_out_types[i], " ", name);
    if (params)
      hash_put(params, e, name);
    else
      free(name);
    res = CONS(expression, copy_expression(e), res);
  }
 
  return gen_nreverse(res);
}

References freia_api_t::arg_in_types, freia_api_t::arg_misc_in, freia_api_t::arg_misc_out, freia_api_t::arg_out_types, CAR, CDR, CONS, copy_expression(), entity_undefined_p, entity_variable_p, EXPRESSION, expression_to_entity(), free(), freia_get_params(), gen_length(), gen_nreverse(), get_bool_property(), get_freia_api(), get_var(), hash_defined_p(), hash_get(), hash_put(), NIL, params, pips_assert, and sb_cat.

Referenced by freia_spoc_pipeline(), freia_terapix_call(), opencl_compile_mergeable_dag(), same_constant_parameters(), and sc_get_params_values().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_get_nth_scalar_param()

expression freia_get_nth_scalar_param	(	const dagvtx	v,
		int	n
	)

Definition at line 589 of file freia-utils.c.

{
  return EXPRESSION(CAR(gen_nthcdr(n-1, freia_get_vertex_params(v))));
}

References CAR, EXPRESSION, freia_get_vertex_params(), and gen_nthcdr().

Referenced by constant_image_p(), copy_image_p(), and propagate_constant_image().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_get_params()

list freia_get_params	(	const freia_api_t *	api,
		list	args
	)

get freia further parameters, skipping image ones

Parameters

api	pi
args	rgs

Definition at line 569 of file freia-utils.c.

{
  int skip = api->arg_img_in + api->arg_img_out;
  while (skip--) args = CDR(args);
  pips_assert("number of scalar args is ok",
              gen_length(args)==api->arg_misc_in+api->arg_misc_out);
  return args;
}

References freia_api_t::arg_img_in, freia_api_t::arg_img_out, freia_api_t::arg_misc_in, freia_api_t::arg_misc_out, CDR, gen_length(), and pips_assert.

Referenced by freia_extract_params(), and freia_get_vertex_params().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_get_vertex_params()

list freia_get_vertex_params

(

const dagvtx

v

)

Definition at line 578 of file freia-utils.c.

{
  const vtxcontent vc = dagvtx_content(v);
  pips_assert("there is a statement",
              pstatement_statement_p(vtxcontent_source(vc)));
  const statement s = pstatement_statement(vtxcontent_source(vc));
  const call c = freia_statement_to_call(s);
  const freia_api_t * api = dagvtx_freia_api(v);
  return freia_get_params(api, call_arguments(c));
}

References call_arguments, dagvtx_content, dagvtx_freia_api, freia_get_params(), freia_statement_to_call(), pips_assert, pstatement_statement, pstatement_statement_p, and vtxcontent_source.

Referenced by freia_convolution_width_height(), freia_extract_kernel_vtx(), freia_get_nth_scalar_param(), freia_terapix_call(), gram_param(), has_vtx_dynamic_params(), mppa_compile_dag(), mppa_helper_args_params(), sc_delimiter(), sc_inst(), sc_kernel_specific_agent(), sigmac_params_decl(), spoc_alu_conf(), spoc_measure_conf(), spoc_poc_conf(), spoc_th_conf(), and terapix_gram_management().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_image_variable_p()

bool freia_image_variable_p

(

const entity

var

)

rather approximative?

Parameters

var

ar

Definition at line 768 of file freia-utils.c.

{
  bool is_image = false;
  if (var && var!=entity_undefined &&
      entity_variable_p(var) && entity_pointer_p(var))
  {
    type t = ultimate_type(entity_type(var));
    basic b = variable_basic(type_variable(t));
    if (basic_pointer_p(b))
    {
      t = basic_pointer(b);
      b = variable_basic(type_variable(t));
      is_image = basic_typedef_p(b) &&
        same_string_p(entity_local_name(basic_typedef(b)),
                      "$" FREIA_IMAGE_TYPE);
    }
  }
 
  pips_debug(8, "%s is%s an image\n", entity_name(var), is_image? "": " not");
  return is_image;
}

References basic_pointer, basic_pointer_p, basic_typedef, basic_typedef_p, entity_local_name(), entity_name, entity_pointer_p(), entity_type, entity_undefined, entity_variable_p, FREIA_IMAGE_TYPE, pips_debug, same_string_p, type_variable, ultimate_type(), and variable_basic.

Referenced by check_ref(), collect_images(), fis_call_flt(), freia_compute_output_images(), freia_shuffle_move_forward(), freia_some_effects_on_images(), image_ref_flt(), oi_call_rwt(), ref_count_rwt(), seq_rwt(), and set_add_scalars().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_init_dep_cache()

void freia_init_dep_cache

(

void

)

Definition at line 909 of file freia-utils.c.

{
  pips_assert("dep_cache is NULL", !dep_cache);
  dep_cache = hash_table_make(hash_pointer, 0);
}

References dep_cache, hash_pointer, hash_table_make(), and pips_assert.

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_insert_added_stats()

void freia_insert_added_stats	(	list	ls,
		list	stats,
		bool	before
	)

insert statements to actual code sequence in "ls" BEWARE that ls is assumed to be in reverse order...

Parameters

ls	s
stats	tats
before	efore

Definition at line 1185 of file freia-utils.c.

{
  if (stats)
  {
    statement sref = find_aipo_statement(ls, before);
    pips_debug(8, "sref for %s is %" _intFMT "\n",
               before? "before": "after", statement_number(sref));
    instruction iref = statement_instruction(sref);
    statement newstat = instruction_to_statement(iref);
    // transfer comments and some cleanup...
    statement_comments(newstat) = statement_comments(sref);
    statement_comments(sref) = string_undefined;
    statement_number(sref) = STATEMENT_NUMBER_UNDEFINED;
    // pretty ugly because return must be handled especially...
    // ??? not sure that it is ok if !before?
    if (instruction_call_p(iref) &&
        ENTITY_C_RETURN_P(call_function(instruction_call(iref))))
    {
      call c = instruction_call(iref);
      if (!expression_constant_p(EXPRESSION(CAR(call_arguments(c)))))
      {
        // must split return...
        pips_internal_error("return splitting not implemented yet...");
      }
      else
      {
        if (before)
          stats = gen_nconc(stats, CONS(statement, newstat, NIL));
        else
          // ???
          stats = CONS(statement, newstat, stats);
      }
    }
    else
    {
      if (before)
        stats = CONS(statement, newstat, stats);
      else
        stats = gen_nconc(stats, CONS(statement, newstat, NIL));
    }
    statement_instruction(sref) =
      make_instruction_sequence(make_sequence(stats));
  }
}

References _intFMT, call_arguments, call_function, CAR, CONS, ENTITY_C_RETURN_P, EXPRESSION, expression_constant_p(), find_aipo_statement(), gen_nconc(), instruction_call, instruction_call_p, instruction_to_statement(), make_instruction_sequence(), make_sequence(), NIL, pips_debug, pips_internal_error, statement_comments, statement_instruction, statement_number, STATEMENT_NUMBER_UNDEFINED, and string_undefined.

Referenced by freia_aipo_compile_calls(), freia_mppa_compile_calls(), freia_opencl_compile_calls(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_max_pixel_value()

int freia_max_pixel_value

(

void

)

Definition at line 594 of file freia-utils.c.

{
  int bpp = FREIA_DEFAULT_BPP;
  switch (bpp)
  {
  case 8: return 0xff;
  case 16: return 0xffff;
  default:
    pips_user_error("expecting 8 or 16 for pixel size, got %d", bpp);
    return 0;
  }
}

References FREIA_DEFAULT_BPP, and pips_user_error.

Referenced by constant_image_p(), and copy_image_p().

Here is the caller graph for this function:

freia_migrate_statements()

void freia_migrate_statements	(	sequence	sq,
		const set	stats,
		const set	before
	)

Parameters

sq	q
stats	tats
before	efore

Definition at line 1905 of file freia-utils.c.

{
  ifdebug(4) {
    pips_debug(4, "migrating %d statements in %p\n", set_size(stats), sq);
    set_fprint(stderr, "stats", stats, (gen_string_func_t) stat_nb);
    set_fprint(stderr, "before", before, (gen_string_func_t) stat_nb);
  }
 
  // nothing to do
  if (sq==NULL)
  {
    pips_assert("nothing to migrate", set_size(stats)<=1);
    return;
  }
 
  // nothing to do either
  if (set_size(stats)==0)
    return;
 
  // build before/in/end statement lists in reverse order
  list lbefore = NIL, lin = NIL, lend = NIL;
  FOREACH(statement, s, sequence_statements(sq))
  {
    if (set_belong_p(stats, s))
      lin = CONS(statement, s, lin);
    else
    {
      if (before && set_belong_p(before, s))
        lbefore = CONS(statement, s, lbefore);
      else
      {
        if (lin)
          lend = CONS(statement, s, lend);
        else
          lbefore = CONS(statement, s, lbefore);
      }
    }
  }
 
  // check consistency
  pips_assert("all statements seen", set_size(stats)==(int) gen_length(lin));
 
  // update sequence
  gen_free_list(sequence_statements(sq));
  lin = gen_nconc(gen_nreverse(lin), gen_nreverse(lend));
  sequence_statements(sq) = gen_nconc(gen_nreverse(lbefore), lin);
}

References CONS, FOREACH, gen_free_list(), gen_length(), gen_nconc(), gen_nreverse(), ifdebug, lend(), NIL, pips_assert, pips_debug, sequence_statements, set_belong_p(), set_fprint(), set_size(), and stat_nb().

Referenced by freia_mppa_compile_calls(), freia_opencl_compile_calls(), migrate_statements(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_ok()

call freia_ok

(

void

)

build all is well freia constant

Definition at line 695 of file freia-utils.c.

{
  // how to build the "FREIA_OK" enum value constant?
  return make_call(local_name_to_top_level_entity("0"), NIL);
}

References local_name_to_top_level_entity(), make_call(), and NIL.

Referenced by freia_cleanup_status(), hwac_kill_statement(), mppa_call_helper(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_scalar_rw_dep()

bool freia_scalar_rw_dep	(	const statement	s,
		const statement	t,
		list *	vars
	)

Parameters

vars

ars

Definition at line 929 of file freia-utils.c.

{
  pips_assert("dep_cache is not NULL", dep_cache);
 
  // short circuit
  if (s==t || !s || !t) return false;
 
  // first level
  if (!hash_defined_p(dep_cache, s))
    hash_put(dep_cache, s, hash_table_make(hash_pointer, 0));
  hash_table h = (hash_table) hash_get(dep_cache, s);
 
  // second level
  if (!hash_defined_p(h, t)) {
    list l = NIL;
    real_freia_scalar_rw_dep(s, t, &l);
    hash_put(h, t, l);
  }
 
  list l = (list) hash_get(h, t);
  if (vars) *vars = gen_copy_seq(l);
  return l!=NIL;
}

References dep_cache, gen_copy_seq(), hash_defined_p(), hash_get(), hash_pointer, hash_put(), hash_table_make(), NIL, pips_assert, and real_freia_scalar_rw_dep().

Referenced by all_previous_stats_with_deps_are_computed(), any_scalar_dep(), and dagvtx_dot().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_spoc_set_operation()

void freia_spoc_set_operation	(	const freia_api_t *	api,
		_int *	type,
		_int *	id
	)

??? beurk: I keep the operation as two ints for code regeneration.

Parameters

api	pi
type	ype
id	d

Definition at line 545 of file freia-utils.c.

{
  pips_assert("no type set", *type == spoc_type_nop);
 
  // set type which is enough for staging?
  if (api->spoc.used==spoc_not_implemented)
    *type = spoc_type_sni;
  else if (api->spoc.used & spoc_alu)
    *type = spoc_type_alu;
  else if (api->spoc.used & (spoc_poc_0|spoc_poc_1))
    *type = spoc_type_poc;
  else if (api->spoc.used & (spoc_th_0|spoc_th_1))
    *type = spoc_type_thr;
  else if (api->spoc.used & (spoc_measure_0|spoc_measure_1))
    *type = spoc_type_mes;
  else
    *type = spoc_type_nop; // e.g. for copy? (...)
 
  // set details
  *id = hwac_freia_api_index(api->function_name);
}

References freia_api_t::function_name, hwac_freia_api_index(), pips_assert, freia_api_t::spoc, spoc_alu, spoc_measure_0, spoc_measure_1, spoc_not_implemented, spoc_poc_0, spoc_poc_1, spoc_th_0, spoc_th_1, spoc_type_alu, spoc_type_mes, spoc_type_nop, spoc_type_poc, spoc_type_sni, spoc_type_thr, and spoc_hw_t::used.

Referenced by dag_append_freia_call().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_statement_aipo_call_p()

bool freia_statement_aipo_call_p

(

const statement

s

)

returns whether the statement is a FREIA call.

Definition at line 814 of file freia-utils.c.

{
  // very partial as well
  instruction i = statement_instruction(s);
  if (instruction_call_p(i)) {
    call c = instruction_call(i);
    entity called = call_function(c);
    if (entity_freia_api_p(called))
      return true;
    else if (freia_assignment_p(called))
    {
      list la = call_arguments(c);
      pips_assert("2 arguments to assign", gen_length(la));
      syntax op2 = expression_syntax(EXPRESSION(CAR(CDR(la))));
      if (syntax_call_p(op2))
        return entity_freia_api_p(call_function(syntax_call(op2)));
    }
    else if (ENTITY_C_RETURN_P(called))
    {
      list la = call_arguments(c);
      if (gen_length(la)==1) {
        syntax op = expression_syntax(EXPRESSION(CAR(la)));
        if (syntax_call_p(op))
          return entity_freia_api_p(call_function(syntax_call(op)));
      }
    }
  }
  return false;
}

References call_arguments, call_function, CAR, CDR, ENTITY_C_RETURN_P, entity_freia_api_p(), EXPRESSION, expression_syntax, freia_assignment_p(), gen_length(), instruction_call, instruction_call_p, pips_assert, statement_instruction, syntax_call, and syntax_call_p.

Referenced by clean_list_head(), freia_cleanup_sequence_rec(), freia_reduction_variable(), fsi_seq_flt(), fsi_stmt_flt(), and set_add_scalars().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_statement_to_call()

call freia_statement_to_call

(

const statement

s

)

return the actual function call from a statement, dealing with assign and returns...

return NULL if not a call.

Definition at line 973 of file freia-utils.c.

{
  // sanity check, somehow redundant
  instruction i = statement_instruction(s);
  call c = instruction_call_p(i)? instruction_call(i): NULL;
  if (c && freia_assignment_p(call_function(c)))
  {
    list args = call_arguments(c);
    pips_assert("2 args", gen_length(args) == 2);
    syntax sy = expression_syntax(EXPRESSION(CAR(CDR(args))));
    c = syntax_call_p(sy)? syntax_call(sy): NULL;
  }
  else if (c && ENTITY_C_RETURN_P(call_function(c)))
  {
    list args = call_arguments(c);
    pips_assert("one arg", gen_length(args)==1);
    syntax sy = expression_syntax(EXPRESSION(CAR(args)));
    c = syntax_call_p(sy)? syntax_call(sy): NULL;
  }
  return c;
}

References call_arguments, call_function, CAR, CDR, ENTITY_C_RETURN_P, EXPRESSION, expression_syntax, freia_assignment_p(), gen_length(), instruction_call, instruction_call_p, pips_assert, statement_instruction, syntax_call, and syntax_call_p.

Referenced by any_use_statement(), dag_append_freia_call(), dag_normalize(), dagvtx_copy_list_dot(), fcs_count(), freia_alloc_stat_p(), freia_cleanup_sequence_rec(), freia_get_vertex_params(), freia_reduction_variable(), freia_spoc_pipeline(), freia_stmt_free_p(), freia_terapix_call(), get_upper_model(), is_freia_this_call(), maybe_unroll_while_rwt(), opencl_compile_mergeable_dag(), opencl_generate_special_kernel_ops(), same_constant_parameters(), sc_get_params_values(), set_aipo_call(), and substitute_image_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_substitute_by_helper_call()

int freia_substitute_by_helper_call	(	dag	d,
		set	global_remainings,
		set	remainings,
		list	ls,
		const string	function_name,
		list	lparams,
		set	helpers,
		int	preceeding
	)

substitute those statement in ls that are in dag d and accelerated by a call to function_name(lparams) also update sets of remainings and global_remainings

the function must chose one of the statements? the current implementation is a buggy mess. it should be fully re-thought from scratch.

what should be done, is to chose the FIRST statement after the LAST dependency of the compiled statements? at least it must exist beacause one of the dependent statement must appear after that, but is it enough for all possible graph? so maybe we should do a topological sort of all the statements and reshuffle everything instead of trying to preserver the initial code as much as possible?

Parameters

global_remainings	lobal_remainings
remainings	emainings
ls	of statement
function_name	unction_name
lparams	params
helpers	elpers
preceeding	receeding

Definition at line 1073 of file freia-utils.c.

{
  pips_debug(7, "%d statements, must come after statement %d\n",
             (int) gen_length(ls), preceeding);
 
  // buid the set of statements that are not yet computed
  set not_dones = set_make(set_pointer), dones = set_make(set_pointer);
  if (d)
  {
    FOREACH(dagvtx, vs, dag_vertices(d))
    {
      pstatement ps = vtxcontent_source(dagvtx_content(vs));
      if (pstatement_statement_p(ps))
        set_add_element(not_dones, not_dones, pstatement_statement(ps));
    }
  }
  // dones: those statements which are handled by this helper
  set_difference(dones, remainings, not_dones);
  // now update remainings & global_remainings
  set_difference(remainings, remainings, dones);
  set_difference(global_remainings, global_remainings, dones);
 
  // replace first statement of dones in ls,
  // which comes after the preceeding ones.
  statement found = NULL, sos = NULL;
  FOREACH(statement, sc, ls)
  {
    pips_debug(5, "in statement %" _intFMT "\n", statement_number(sc));
    if (set_belong_p(dones, sc))
    {
      sos = sos? (statement_number(sc)<statement_number(sos)? sc: sos): sc;
      if (statement_number(sc)>preceeding)
      {
        pips_assert("statement is a call", statement_call_p(sc));
        found = found?
          (statement_number(sc)<statement_number(found)? sc: found): sc;
      }
    }
  }
 
  if (!found)
  {
    pips_user_warning("no statement found after preceeding insertion, "
                      "using first statement as backup...\n");
    // use backup
    found = sos;
  }
 
  pips_assert("some statement found", found);
 
  // create and record helper function
  entity helper = freia_create_helper_function(function_name, lparams);
  set_add_element(helpers, helpers, helper);
 
  // substitute by call to helper
  call c = make_call(helper, lparams);
 
  hwac_replace_statement(found, c, false);
 
  set_free(not_dones);
  set_free(dones);
 
  return statement_number(found);
}

References _intFMT, dag_vertices, dagvtx_content, FOREACH, freia_create_helper_function(), gen_length(), hwac_replace_statement(), lparams, make_call(), pips_assert, pips_debug, pips_user_warning, pstatement_statement, pstatement_statement_p, set_add_element(), set_belong_p(), set_difference(), set_free(), set_make(), set_pointer, statement_call_p(), statement_number, and vtxcontent_source.

Referenced by freia_trpx_compile_one_dag(), and opencl_compile_mergeable_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

get_assigned_variable()

static entity get_assigned_variable ( const statement  s )

static

for "ret = freia_aipo_*()": return the 'ret' variable...

return NULL if not an assignment

Definition at line 793 of file freia-utils.c.

{
  entity assigned = NULL;
  pips_assert("statement is a call", statement_call_p(s));
  call c = instruction_call(statement_instruction(s));
  entity called = call_function(c);
  if (freia_assignment_p(called))
    assigned = expression_to_entity(EXPRESSION(CAR(call_arguments(c))));
  return assigned;
}

References call_arguments, call_function, CAR, EXPRESSION, expression_to_entity(), freia_assignment_p(), instruction_call, pips_assert, statement_call_p(), and statement_instruction.

Referenced by set_add_scalars().

Here is the call graph for this function:

Here is the caller graph for this function:

get_freia_api()

const freia_api_t* get_freia_api

(

int

index

)

Parameters

index

ndex

Definition at line 477 of file freia-utils.c.

{
  // pips_assert("index exists", index>=0 && index<(int) FREIA_AIPO_API_SIZE);
  return &FREIA_AIPO_API[index];
}

References FREIA_AIPO_API.

Referenced by commutative_operation_p(), constant_image_p(), copy_image_p(), dagvtx_compact_operation(), dagvtx_function_name(), dagvtx_is_measurement_p(), dagvtx_is_operator_p(), freia_extract_params(), freia_spoc_pipeline(), freia_terapix_call(), get_freia_api_vtx(), opencl_compile_mergeable_dag(), and propagate_constant_image().

Here is the caller graph for this function:

get_freia_api_vtx()

const freia_api_t* get_freia_api_vtx

(

dagvtx

v

)

Definition at line 483 of file freia-utils.c.

{
  return get_freia_api(vtxcontent_opid(dagvtx_content(v)));
}

References dagvtx_content, get_freia_api(), and vtxcontent_opid.

Referenced by dagvtx_constant_kernel_p(), has_vtx_dynamic_params(), mppa_compile_dag(), opencl_generate_special_kernel_ops(), opencl_merge_and_compile(), sc_delimiter(), sc_inst(), sc_vtx_tostring(), sigmac_name_instances(), and sigmac_params_decl().

Here is the call graph for this function:

Here is the caller graph for this function:

get_var()

static string get_var ( string  prefix, int *  params  )

static

Returns

new allocated variable name using provided prefix. *params is incremented as a side effect.

Definition at line 491 of file freia-utils.c.

{
  return strdup(cat(prefix, i2a((*params)++)));
}

References cat, i2a(), params, prefix, and strdup().

Referenced by freia_extract_params().

Here is the call graph for this function:

Here is the caller graph for this function:

helper_file_name()

string helper_file_name	(	string	func_name,
		string	suffix
	)

return malloc'ed "foo.database/Src/%{module}_helper_functions.c" should it depend on the target? no, because we could mix targets?

Parameters

func_name	unc_name
suffix	uffix

Definition at line 2029 of file freia-utils.c.

{
  string src_dir = db_get_directory_name_for_module(func_name);
  string fn = strdup(cat(src_dir, "/", func_name, HELPER "functions.", suffix));
  free(src_dir);
  return fn;
}

References cat, db_get_directory_name_for_module(), free(), HELPER, and strdup().

Referenced by freia_compile(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

hwac_freia_api()

const freia_api_t* hwac_freia_api

(

const char *

function

)

freia-utils.c

Returns

the description of a FREIA AIPO API function. may be moved elswhere. raise an error if not found.

Parameters

function

unction

Definition at line 455 of file freia-utils.c.

{
  static hash_table cache = NULL;
  if (!cache)
  {
    const freia_api_t * api;
    cache = hash_table_make(hash_string, 0);
    for (api = FREIA_AIPO_API; api->function_name; api++)
      hash_put(cache, api->function_name, api);
  }
  return (const freia_api_t *)
    (hash_defined_p(cache, function)? hash_get(cache, function): NULL);
}

References FREIA_AIPO_API, freia_api_t::function_name, hash_defined_p(), hash_get(), hash_put(), hash_string, and hash_table_make().

Referenced by dag_append_freia_call(), freia_cleanup_sequence_rec(), freia_terapix_call(), hwac_freia_api_index(), reference_written_p(), sio_call_flt(), and swis_call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

hwac_freia_api_index()

int hwac_freia_api_index

(

const string

function

)

returns the index of the description of an AIPO function

Parameters

function

unction

Definition at line 471 of file freia-utils.c.

{
  const freia_api_t * api = hwac_freia_api(function);
  return api? (api - FREIA_AIPO_API): -1;
}

References FREIA_AIPO_API, and hwac_freia_api().

Referenced by commutative_operation_p(), dag_normalize(), freia_spoc_set_operation(), set_aipo_call(), switch_vertex_to_a_copy(), and switch_vertex_to_assign().

Here is the call graph for this function:

Here is the caller graph for this function:

hwac_kill_statement()

void hwac_kill_statement

(

statement

s

)

remove contents of statement s.

Definition at line 761 of file freia-utils.c.

{
  hwac_replace_statement(s, freia_ok(), true);
}

References freia_ok(), and hwac_replace_statement().

Referenced by freia_dag_optimize(), freia_spoc_pipeline(), freia_terapix_call(), and opencl_compile_mergeable_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

hwac_replace_statement()

void hwac_replace_statement	(	statement	s,
		call	newc,
		bool	kill
	)

replace statement contents with call to c, or continue if kill

Parameters

newc	ewc
kill	ill

Definition at line 720 of file freia-utils.c.

{
  instruction old = statement_instruction(s);
  pips_assert("must kill a call", instruction_call_p(old));
  call c = instruction_call(old);
  entity called = call_function(c);
  if (ENTITY_C_RETURN_P(called))
  {
    // replace argument list
    gen_full_free_list(call_arguments(c));
    call_arguments(c) = CONS(expression, call_to_expression(newc), NIL);
  }
  else if (freia_assignment_p(called))
  {
    // new second argument
    list largs = call_arguments(c);
    pips_assert("two arguments to assignment", gen_length(largs)==2);
    expression first = EXPRESSION(CAR(largs));
    free_expression(EXPRESSION(CAR(CDR(largs))));
    gen_free_list(largs), largs = NIL;
    call_arguments(c) =
      CONS(expression, first, CONS(expression, call_to_expression(newc), NIL));
  }
  else
  {
    free_instruction(old);
    if (kill)
    {
      // ??? in C, it is not a do nothing instruction!
      statement_instruction(s) = make_continue_instruction();
      free_call(newc);
    }
    else
    {
      statement_instruction(s) = make_instruction_call(newc);
    }
  }
}

References call_arguments, call_function, call_to_expression(), CAR, CDR, CONS, ENTITY_C_RETURN_P, EXPRESSION, free_call(), free_expression(), free_instruction(), freia_assignment_p(), gen_free_list(), gen_full_free_list(), gen_length(), instruction_call, instruction_call_p, make_continue_instruction(), make_instruction_call(), NIL, pips_assert, and statement_instruction.

Referenced by freia_substitute_by_helper_call(), hwac_kill_statement(), mppa_call_helper(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

image_free()

static statement image_free ( entity  v )

static

generate statement: "freia_free(v);"

Definition at line 1484 of file freia-utils.c.

{
  return call_to_statement(
    make_call(local_name_to_top_level_entity(FREIA_FREE),
              CONS(expression, entity_to_expression(v), NIL)));
}

References call_to_statement, CONS, entity_to_expression(), FREIA_FREE, local_name_to_top_level_entity(), make_call(), and NIL.

Referenced by freia_allocate_new_images_if_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

is_freia_alloc()

bool is_freia_alloc

(

const statement

s

)

Definition at line 1002 of file freia-utils.c.

{
  return is_freia_this_call(s, FREIA_ALLOC);
}

References FREIA_ALLOC, and is_freia_this_call().

Referenced by freia_cmp_statement(), freia_memory_management_statement(), and get_upper_model().

Here is the call graph for this function:

Here is the caller graph for this function:

is_freia_dealloc()

bool is_freia_dealloc

(

const statement

s

)

Definition at line 1007 of file freia-utils.c.

{
  return is_freia_this_call(s, FREIA_FREE);
}

References FREIA_FREE, and is_freia_this_call().

Referenced by freia_cleanup_sequence_rec(), freia_cmp_statement(), and freia_memory_management_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

is_freia_this_call()

static bool is_freia_this_call ( const statement  s, const string  fname  )

static

Definition at line 995 of file freia-utils.c.

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

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

Referenced by is_freia_alloc(), and is_freia_dealloc().

Here is the call graph for this function:

Here is the caller graph for this function:

lexpression_equal_p()

static bool lexpression_equal_p ( const list  l1, const list  l2  )

static

Definition at line 953 of file freia-utils.c.

{
  bool equal = true;
  int n1 = gen_length(l1), n2 = gen_length(l2);
  if (n1==n2) {
    list p1 = (list) l1, p2 = (list) l2;
    while (equal && p1 && p2) {
      if (!expression_equal_p(EXPRESSION(CAR(p1)), EXPRESSION(CAR(p2))))
        equal = false;
      p1 = CDR(p1), p2 = CDR(p2);
    }
  }
  else
    equal = false;
  return equal;
}

References CAR, CDR, EXPRESSION, expression_equal_p(), and gen_length().

Referenced by same_constant_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

oi_call_rwt()

static void oi_call_rwt ( call  c, set  images  )

static

Definition at line 1841 of file freia-utils.c.

{
  entity called = call_function(c);
  list args = call_arguments(c);
  if (!args) return;
  if (ENTITY_RETURN_P(called) ||
      same_string_p(entity_local_name(called), FREIA_OUTPUT))
  {
    entity var = expression_to_entity(EXPRESSION(CAR(args)));
    if (freia_image_variable_p(var))
      set_add_element(images, images, var);
  }
}

References call_arguments, call_function, CAR, entity_local_name(), ENTITY_RETURN_P, EXPRESSION, expression_to_entity(), freia_image_variable_p(), FREIA_OUTPUT, same_string_p, and set_add_element().

Referenced by freia_compute_output_images(), and oi_stmt_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

oi_stmt_rwt()

static void oi_stmt_rwt ( statement  s, set  images  )

static

Definition at line 1855 of file freia-utils.c.

{
  FOREACH(entity, var, statement_declarations(s))
    gen_context_recurse(entity_initial(var), images,
                        call_domain, gen_true2, oi_call_rwt);
}

References call_domain, entity_initial, FOREACH, gen_context_recurse, gen_true2(), oi_call_rwt(), and statement_declarations.

Referenced by freia_compute_output_images().

Here is the call graph for this function:

Here is the caller graph for this function:

only_minor_statements_in_between()

static bool only_minor_statements_in_between ( entity  image, hash_table  new_images, hash_table  image_stats, list  ls, statement  s1, list  l2, set  image_occurences  )

static

tell whether there is no image processing statements between s1 and l2

Definition at line 1572 of file freia-utils.c.

{
  bool s1_seen = false, in_sequence = false;
  pips_assert("consistent statement & list", !gen_in_list_p(s1, l2));
  int n2 = gen_length(l2);
 
  ifdebug(8) {
    pips_debug(8, "img=%s s=%"_intFMT"\nls = (\n",
               entity_local_name(image), statement_number(s1));
    FOREACH(statement, sls, ls)
      pips_debug(8, " - %"_intFMT" %s\n", statement_number(sls),
                 sls==s1? "!": gen_in_list_p(sls, l2)? "*": "");
    pips_debug(8, ")\n");
  }
 
  // scan the sequence list, looking for s1 & l2 statements
  FOREACH(statement, s, ls)
  {
    if (!in_sequence && s==s1)
      in_sequence = true, s1_seen = true;
    else if (in_sequence && gen_in_list_p(s, l2))
    {
      n2--;
      if (n2) {
        // we are still going on, BUT we must check that this statement
        // does not rewrite the image we are interested in and may change back.
        if (some_related_image_effect(s, image, new_images, image_stats, true))
          return false;
      }
      // we stop when we have seen all intermediate statements
      else
        return true;
    }
    else if (in_sequence && set_belong_p(image_occurences, s))
    {
      // let us try to do something intelligent here...
      // if images are unrelated to "image", then there will be no interaction
      if (some_related_image_effect(s, image, new_images, image_stats, false))
        return false;
    }
  }
 
  // ??? should really be an error...
  pips_user_warning("should not get there: s1 seen=%s, seq=%s, n2=%d\n",
                    bool_to_string(s1_seen), bool_to_string(in_sequence), n2);
 
  // let us be optimistic, this is a prototype
  return true;
}

References _intFMT, bool_to_string(), entity_local_name(), FOREACH, gen_in_list_p(), gen_length(), ifdebug, related_ctx::image_stats, related_ctx::new_images, pips_assert, pips_debug, pips_user_warning, s1, set_belong_p(), some_related_image_effect(), and statement_number.

Referenced by freia_allocate_new_images_if_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

real_freia_scalar_rw_dep()

static bool real_freia_scalar_rw_dep ( const statement  s, const statement  t, list *  vars  )

static

is there a simple scalar (no image) rw dependency from s to t? WW deps are ignored...

should be okay of computed in order?

Parameters

s	source statement
t	target statement
vars	if set, return list of scalars which hold the dependencies

Definition at line 881 of file freia-utils.c.

{
  // pips_assert("distinct statements", s!=t);
  if (s==t || !s || !t) return false;
  // I should really use entities_may_conflict_p...
  set reads = set_make(set_pointer), writes = set_make(set_pointer);
  set_add_scalars(writes, s, true);
  set_add_scalars(reads, t, false);
  set inter = set_make(set_pointer);
  set_intersection(inter, reads, writes);
  bool rw_dep = !set_empty_p(inter);
  if (vars)
    *vars = set_to_sorted_list(inter, (gen_cmp_func_t) compare_entities);
  set_free(reads);
  set_free(writes);
  set_free(inter);
  pips_debug(8, "%" _intFMT " %sdependent from %" _intFMT "\n",
             statement_number(t), rw_dep? "": "in", statement_number(s));
  return rw_dep;
}

References _intFMT, compare_entities(), pips_debug, set_add_scalars(), set_empty_p(), set_free(), set_intersection(), set_make(), set_pointer, set_to_sorted_list(), and statement_number.

Referenced by freia_scalar_rw_dep().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_argument_number()

static int reference_argument_number ( const reference  r, const list  le  )

static

return the argument number, starting from 1, of this reference or 0 if not found.

Definition at line 1253 of file freia-utils.c.

{
  int n = 0, i=0;
  FOREACH(expression, e, le)
  {
    i++;
    if (expression_reference_p(e) && expression_reference(e)==r)
      n = i;
  }
  return n;
}

References expression_reference(), expression_reference_p(), and FOREACH.

Referenced by reference_written_p().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_written_p()

static bool reference_written_p ( const reference  r, const hash_table  signatures  )

static

tell about the image effect.

if in doubt, return true.

Definition at line 1267 of file freia-utils.c.

{
  const char* why = "default", *func = "?";
  bool written = false;
  call c = (call) gen_get_ancestor(call_domain, r);
  if (c)
  {
    entity called = call_function(c);
    func = entity_local_name(called);
    int n = reference_argument_number(r, call_arguments(c));
    if (n==0)
      written=true, why = "not found";
    else
    {
      const freia_api_t * api = hwac_freia_api(entity_local_name(called));
      if (api)
        written = n <= (int) api->arg_img_out, why = "api";
      else
        if (signatures && hash_defined_p(signatures, called))
          written = n <= (_int) hash_get(signatures, called), why = "sig";
        else
          written = true, why = "no sig";
    }
  }
  else
    // in doubt, assume a write effect?
    pips_internal_error("reference to %s outside of a call?\n",
                        entity_local_name(reference_variable(r)));
 
  pips_debug(8, "reference to %s is %s (%s in %s)\n",
             entity_local_name(reference_variable(r)),
             written? "written": "read", why, func);
 
  return written;
}

References freia_api_t::arg_img_out, call_arguments, call_domain, call_function, entity_local_name(), gen_get_ancestor(), hash_defined_p(), hash_get(), hwac_freia_api(), if(), int, pips_debug, pips_internal_error, reference_argument_number(), reference_variable, and written.

Referenced by check_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

related_effect()

static bool related_effect ( statement  s, struct related_ctx *  ctx  )

static

Definition at line 1524 of file freia-utils.c.

{
  pips_debug(8, "on statement %"_intFMT"\n", statement_number(s));
  entity written = NULL;
  SET_FOREACH(entity, w, (set) hash_get(ctx->image_stats, E_WRITE(s)))
  {
    if (related_images_p(ctx->img, w, ctx->new_images))
    {
      pips_debug(8, "W relation for %s & %s\n",
                 entity_local_name(ctx->img), entity_local_name(w));
      ctx->some_effect = true;
      gen_recurse_stop(NULL);
      return false;
    }
    written = w;
  }
  if (!ctx->write_only)
  {
    pips_assert("some written stuff", written);
    SET_FOREACH(entity, r, (set) hash_get(ctx->image_stats, E_READ(s)))
    {
      if (related_images_p(ctx->img, r, ctx->new_images))
      {
        pips_debug(8, "R relation for %s & %s\n",
                   entity_local_name(ctx->img), entity_local_name(written));
        ctx->some_effect = true;
        gen_recurse_stop(NULL);
        return false;
      }
    }
  }
  return true;
}

References _intFMT, E_READ, E_WRITE, entity_local_name(), gen_recurse_stop(), hash_get(), related_ctx::image_stats, related_ctx::img, related_ctx::new_images, pips_assert, pips_debug, related_images_p(), SET_FOREACH, related_ctx::some_effect, statement_number, related_ctx::write_only, and written.

Referenced by some_related_image_effect().

Here is the call graph for this function:

Here is the caller graph for this function:

related_images_p()

static bool related_images_p ( const entity  img1, const entity  img2, const hash_table  new_images  )

static

is there an effect to this image or related images in the statement?

are img1 and img2 related?

Definition at line 1504 of file freia-utils.c.

{
  entity oimg1 = NULL, oimg2 = NULL;
  if (img1==img2) return true;
  if (hash_defined_p(new_images, img1))
    oimg1 = (entity) hash_get(new_images, img1);
  if (hash_defined_p(new_images, img2))
    oimg2 = (entity) hash_get(new_images, img2);
 
  pips_debug(9, "images: %s -> %s / %s -> %s\n",
             entity_local_name(img1), oimg1? entity_local_name(oimg1): "NONE",
             entity_local_name(img2), oimg2? entity_local_name(oimg2): "NONE");
 
  if (oimg1 && oimg1==img2) return true;
  if (oimg2 && img1==oimg2) return true;
  // this is really the one which should be triggered?
  return oimg1 && oimg2 && oimg1==oimg2;
}

References entity_local_name(), hash_defined_p(), hash_get(), and pips_debug.

Referenced by related_effect().

Here is the call graph for this function:

Here is the caller graph for this function:

same_constant_parameters()

bool same_constant_parameters	(	const dagvtx	v1,
		const dagvtx	v2
	)

tell whether v1 and v2 point to statements with the same parameters.

Parameters

v1	1
v2	2

Definition at line 1014 of file freia-utils.c.

{
  call
    c1 = freia_statement_to_call(dagvtx_statement(v1)),
    c2 = freia_statement_to_call(dagvtx_statement(v2));
  list
    lp1 = freia_extract_params
    (dagvtx_opid(v1), call_arguments(c1), NULL, NULL, NULL, NULL),
    lp2 = freia_extract_params
    (dagvtx_opid(v1), call_arguments(c2), NULL, NULL, NULL, NULL);
  bool same = lexpression_equal_p(lp1, lp2);
  gen_free_list(lp1), gen_free_list(lp2);
  // should also check that there is no w effects on parameters in between
  return same;
}

References call_arguments, dagvtx_opid(), dagvtx_statement(), freia_extract_params(), freia_statement_to_call(), gen_free_list(), and lexpression_equal_p().

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

set_add_scalars()

static void set_add_scalars ( set  s, const statement  stat, const bool  written  )

static

append simple scalar entities with written/read effects to s scalars assigned to are ignored (return status).

no attempt at managing aliasing or the like...

Definition at line 850 of file freia-utils.c.

{
  effects efs = load_cumulated_rw_effects(stat);
  entity skip = NULL;
 
  // skip assigned variable of AIPO calls
  if (freia_statement_aipo_call_p(stat))
    skip = get_assigned_variable(stat);
 
  FOREACH(effect, e, effects_effects(efs))
  {
    if (!malloc_effect_p(e) &&
        ((written && effect_write_p(e)) || (!written && effect_read_p(e))))
    {
      entity var = reference_variable(effect_any_reference(e));
      if (entity_variable_p(var) && var!=skip &&
          !freia_image_variable_p(var) && (entity_scalar_p(var) || entity_pointer_p(var)))
        set_add_element(s, s, var);
    }
  }
}

References effect_any_reference, effect_read_p, effect_write_p, effects_effects, entity_pointer_p(), entity_scalar_p(), entity_variable_p, FOREACH, freia_image_variable_p(), freia_statement_aipo_call_p(), get_assigned_variable(), load_cumulated_rw_effects(), malloc_effect_p(), reference_variable, set_add_element(), and written.

Referenced by real_freia_scalar_rw_dep().

Here is the call graph for this function:

Here is the caller graph for this function:

some_related_image_effect()

static bool some_related_image_effect ( statement  s, entity  img, hash_table  new_images, hash_table  image_stats, bool  write_only  )

static

Definition at line 1558 of file freia-utils.c.

{
  struct related_ctx ctx = { img, new_images, image_stats, write_only, false };
  gen_context_recurse(s, &ctx, statement_domain, related_effect, gen_null2);
  return ctx.some_effect;
}

References gen_context_recurse, gen_null2(), related_ctx::image_stats, related_ctx::img, related_ctx::new_images, related_effect(), related_ctx::some_effect, statement_domain, and related_ctx::write_only.

Referenced by only_minor_statements_in_between().

Here is the call graph for this function:

Here is the caller graph for this function:

stat_nb()

static string stat_nb ( statement  s )

static

Definition at line 1893 of file freia-utils.c.

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

References i2a(), and statement_number.

Referenced by freia_migrate_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

what_operation()

string what_operation

(

const _int

type

)

Returns

a string which describes the type of operation (i.e. the hardware used by the function for spoc).

Definition at line 499 of file freia-utils.c.

{
  switch (type)
  {
  case spoc_type_sni: return "sni";
  case spoc_type_oth: return "other";
  case spoc_type_nop: return "none";
  case spoc_type_inp: return "input";
  case spoc_type_poc: return "poc";
  case spoc_type_alu: return "alu";
  case spoc_type_mes: return "measure";
  case spoc_type_thr: return "threshold";
  case spoc_type_out: return "output";
  default: return "unexpected value...";
  }
}

References spoc_type_alu, spoc_type_inp, spoc_type_mes, spoc_type_nop, spoc_type_oth, spoc_type_out, spoc_type_poc, spoc_type_sni, and spoc_type_thr.

Referenced by basic_spoc_conf(), comment(), dagvtx_dump(), generate_wiring(), print_op_schedule(), and where_to_perform_operation().

Here is the caller graph for this function:

what_operation_shape()

string what_operation_shape

(

const _int

type

)

SPoC: set shape depending on hardware component used by vertex.

Definition at line 518 of file freia-utils.c.

{
  string shape;
  switch (type)
  {
  case spoc_type_oth:
    shape = "shape=none"; break;
  case spoc_type_poc:
    shape = "shape=box"; break;
  case spoc_type_alu:
    shape = "shape=trapezium,orientation=270"; break;
  case spoc_type_thr:
    shape = "shape=parallelogram"; break;
  case spoc_type_mes:
    shape = "shape=diamond"; break;
    // these should not happen
  case spoc_type_out:
  case spoc_type_inp:
  case spoc_type_nop:
  default:
    shape = "shape=circle";
  }
  return shape;
}

References spoc_type_alu, spoc_type_inp, spoc_type_mes, spoc_type_nop, spoc_type_oth, spoc_type_out, spoc_type_poc, and spoc_type_thr.

Referenced by dagvtx_dot().

Here is the caller graph for this function:

Variable Documentation

dep_cache

hash_table dep_cache = NULL

static

Definition at line 907 of file freia-utils.c.

Referenced by freia_close_dep_cache(), freia_init_dep_cache(), and freia_scalar_rw_dep().

FREIA_AIPO_API

const freia_api_t FREIA_AIPO_API[]

static

!!! there are some underlying assumptions when using this structure: only one of ALU/POC/MES is used per AIPO.

only the first of two POC or MES is used per AIPO. ??? conversions between 8/16 bits images are definitely not handled here.

Definition at line 99 of file freia-utils.c.

Referenced by get_freia_api(), hwac_freia_api(), and hwac_freia_api_index().