hwac.h File Reference

#include "freia_spoc_private.h"

Include dependency graph for hwac.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
bool	freia_spoc_compiler (const string)
	Warning! Do not modify this file that is automatically generated! More...
bool	freia_terapix_compiler (const string)
bool	freia_aipo_compiler (const string)
bool	freia_opencl_compiler (const string)
bool	freia_sigmac_compiler (const string)
bool	freia_mppa_compiler (const string)
bool	freia_some_effects_on_images (statement)
	freia.c More...
expression	freia_transpose_kernel (const expression)
	Transpose a structuring element expression. More...
bool	freia_is_transpose_call (statement)
	Detect a call to a se transposition function and transpose the arguments. More...
string	freia_compile (string, statement, string)
	freia_compile: compile freia module & statement for target More...
list	freia_spoc_compile_calls (string, dag, sequence, list, const hash_table, hash_table, const set, FILE *, set, int)
	freia_spoc.c More...
list	freia_trpx_compile_calls (string, dag, sequence, list, const hash_table, hash_table, const set, FILE *, set, int)
	freia_terapix.c More...
list	freia_opencl_compile_calls (string, dag, sequence, list, const hash_table, hash_table, const set, FILE *, set, int, hash_table)
	freia_opencl.c More...
list	freia_aipo_compile_calls (string, dag, list, const hash_table, hash_table, int)
	freia_aipo.c More...
list	freia_sigmac_compile_calls (string, dag, sequence, list, const hash_table, hash_table, const set, FILE *, set, int, int)
	freia_sigmac.c More...
list	freia_mppa_compile_calls (string, dag, sequence, list, const hash_table, hash_table, const set, FILE *, set, int)
	freia_mppa.c More...
string	dagvtx_to_string (const dagvtx)
	dag-utils.c More...
statement	dagvtx_statement (const dagvtx)
	return statement if any, or NULL (for input nodes). More...
void	dag_statements (set, const dag)
	build the set of actual statements in d More...
bool	dagvtx_other_stuff_p (const dagvtx)
	a vertex with a non AIPO or image related statement. More...
entity	dagvtx_image (const dagvtx)
	return the produced image or NULL More...
_int	dagvtx_number (const dagvtx)
	returns the vertex number, i.e. More...
string	dagvtx_number_str (const dagvtx)
_int	dagvtx_optype (const dagvtx)
_int	dagvtx_opid (const dagvtx)
string	dagvtx_function_name (const dagvtx)
string	dagvtx_operation (const dagvtx)
string	dagvtx_compact_operation (const dagvtx)
int	dagvtx_ordering (const dagvtx *, const dagvtx *)
dagvtx	dagvtx_get_producer (const dag, const dagvtx, const entity, _int)
	return (last) producer of image e for vertex sink, or NULL if none found. More...
void	dagvtx_nb_dump (FILE *, const string, const list)
void	dagvtx_dump (FILE *, const string, const dagvtx)
	for dag debug. More...
void	dag_dump (FILE *, const string, const dag)
	for dag debug More...
void	dag_dot (FILE *, const string, const dag, const list, const list)
	output dag in dot format, for debug or show More...
void	dag_dot_dump (const string, const string, const dag, const list, const list)
	generate a "dot" format from a dag to a file. More...
void	dag_dot_dump_prefix (const string, const string, int, const dag, const list, const list)
void	dag_consistency_asserts (dag)
	do some consistency checking... More...
void	dag_remove_vertex (dag, const dagvtx)
	remove vertex v from dag d. More...
dagvtx	copy_dagvtx_norec (dagvtx)
	copy a vertex, but without its successors. More...
bool	dagvtx_is_measurement_p (const dagvtx)
	returns whether the vertex is an image measurement operation. More...
void	dag_append_vertex (dag, dagvtx)
	append new vertex nv to dag d. More...
int	dag_computation_count (const dag)
	return the number of actual operations in dag d. More...
list	dag_vertex_preds (const dag, const dagvtx)
	return target predecessor vertices as a list. More...
void	freia_dag_optimize (dag, hash_table, list *, list *)
	remove dead image operations. More...
void	dag_compute_outputs (dag, const hash_table, const set, const list, bool)
	(re)compute the list of GLOBAL input & output images for this dag ??? BUG the output is rather an approximation should rely on used defs or out effects for the underlying sequence. More...
void	freia_hack_fix_global_ins_outs (dag, dag)
	catch some cases of missing outs between splits... More...
void	dag_cleanup_other_statements (dag)
	remove unneeded statements? you must know they are really un-needed! More...
bool	single_image_assignement_p (dag)
	??? I'm unsure about what happens to dead code in the pipeline... More...
list	dag_computable_vertices (dag, const set, const set, const set)
	return the vertices which may be computed from the list of available images, excluding vertices in exclude. More...
void	set_append_vertex_statements (set, list)
dag	freia_build_dag (string, list, int, const hash_table, const set, const list, bool)
	build a full dag from list of statements ls. More...
bool	dag_no_image_operation (dag)
	tell whether we have something to do with images ??? hmmm... More...
statement	freia_memory_management_statement (entity, const hash_table, bool)
void	freia_switch_image_in_statement (statement, entity, entity, bool)
	switch read or written image in statement if this is an AIPO call, only substitute output or input depending on write otherwise all occurrences are substituted More...
list	dag_fix_image_reuse (dag, hash_table, const hash_table)
	fix intermediate image reuse in dag More...
list	dag_split_on_scalars (const dag, bool(*)(const dagvtx), dagvtx(*)(const list, bool), gen_cmp_func_t, void(*)(const dag), const set)
	split a dag on scalar dependencies only, with a greedy heuristics. More...
list	dag_connected_component (dag, list *, bool(*)(const dagvtx, const set, const dag))
	extract a sublist of lv which is a connected component. More...
list	dag_split_connected_components (dag, set)
	build connected components More...
const freia_api_t *	hwac_freia_api (const char *)
	freia-utils.c More...
int	hwac_freia_api_index (const string)
	returns the index of the description of an AIPO function More...
const freia_api_t *	get_freia_api (int)
const freia_api_t *	get_freia_api_vtx (dagvtx)
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 *, _int *, _int *)
	??? beurk: I keep the operation as two ints for code regeneration. More...
list	freia_get_params (const freia_api_t *, list)
	get freia further parameters, skipping image ones More...
list	freia_get_vertex_params (const dagvtx)
expression	freia_get_nth_scalar_param (const dagvtx, int)
int	freia_max_pixel_value (void)
list	freia_extract_params (const int, list, string_buffer, string_buffer, hash_table, int *)
	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)
	tell whether it is an assignment to ignore? More...
statement	freia_copy_image (const entity, const entity)
void	hwac_replace_statement (statement, call, bool)
	replace statement contents with call to c, or continue if kill More...
void	hwac_kill_statement (statement)
	remove contents of statement s. More...
bool	freia_image_variable_p (const entity)
	rather approximative? More...
bool	entity_freia_api_p (const entity)
	returns whether the entity is a freia API (AIPO) function. More...
bool	freia_statement_aipo_call_p (const statement)
	returns whether the statement is a FREIA call. More...
void	freia_init_dep_cache (void)
void	freia_close_dep_cache (void)
bool	freia_scalar_rw_dep (const statement, const statement, list *)
call	freia_statement_to_call (const statement)
	return the actual function call from a statement, dealing with assign and returns... More...
bool	is_freia_alloc (const statement)
bool	is_freia_dealloc (const statement)
bool	same_constant_parameters (const dagvtx, const dagvtx)
	tell whether v1 and v2 point to statements with the same parameters. More...
entity	freia_create_helper_function (const string, list)
int	freia_substitute_by_helper_call (dag, set, set, list, const string, list, set, int)
	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...
void	freia_insert_added_stats (list, list, bool)
	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, list *)
	prepend limg images in front of the argument list limg is consummed by the operation. More...
hash_table	freia_build_image_occurrences (statement, set, hash_table, const hash_table)
void	freia_clean_image_occurrences (hash_table)
	cleanup occurrence data structure More...
bool	freia_aipo_spoc_implemented (const freia_api_t *)
	whether api available with SPoC More...
bool	freia_aipo_terapix_implemented (const freia_api_t *)
	whether api available with Ter@pix More...
bool	freia_convolution_p (dagvtx)
	is it the convolution special case? More...
bool	freia_convolution_width_height (dagvtx, _int *, _int *, bool)
	get width & height of convolution More...
list	freia_allocate_new_images_if_needed (list, list, const hash_table, const hash_table, const hash_table)
	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, int *, int *)
set	freia_compute_output_images (entity, statement)
set	freia_compute_current_output_images (void)
void	freia_migrate_statements (sequence, const set, const set)
bool	freia_extract_kernel_vtx (dagvtx, bool, intptr_t *, intptr_t *, intptr_t *, intptr_t *, intptr_t *, intptr_t *, intptr_t *, intptr_t *, intptr_t *)
	vertex-based version More...
string	helper_file_name (string, string)
	return malloc'ed "foo.database/Src/%{module}_helper_functions.c" should it depend on the target? no, because we could mix targets? More...
bool	freia_unroll_while (const string)
	freia_transformations.c More...
bool	freia_remove_scalar_ww_deps (const string)
bool	remove_simple_scalar_pointers (const string)
void	freia_shuffle_move_forward (statement)

Function Documentation

copy_dagvtx_norec()

dagvtx copy_dagvtx_norec

(

dagvtx

v

)

copy a vertex, but without its successors.

Definition at line 611 of file dag-utils.c.

{
  list lsave = dagvtx_succs(v);
  // temporary cut costs
  dagvtx_succs(v) = NIL;
  dagvtx copy = copy_dagvtx(v);
  dagvtx_succs(v) = lsave;
  return copy;
}

References copy_dagvtx(), dagvtx_succs, and NIL.

Referenced by compile_this_list(), dag_split_connected_components(), dag_split_on_scalars(), and opencl_generate_special_kernel_ops().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_append_vertex()

void dag_append_vertex	(	dag	d,
		dagvtx	nv
	)

append new vertex nv to dag d.

Parameters

nv

v

Definition at line 632 of file dag-utils.c.

{
  pips_assert("not in dag", !gen_in_list_p(nv, dag_vertices(d)));
  pips_assert("no successors", dagvtx_succs(nv) == NIL);
 
  // pips_assert("dag d ok 1", dag_consistent_p(d));
  // pips_assert("nv is ok", dagvtx_consistent_p(nv));
 
  FOREACH(entity, e, vtxcontent_inputs(dagvtx_content(nv)))
  {
    pips_assert("e is defined", e!=entity_undefined);
    dagvtx pv = dagvtx_get_producer(d, NULL, e, dagvtx_number(nv));
    if (!pv)
    {
      // side effect, create an input node of type 0 (not a computation)
      pv = make_dagvtx
        (make_vtxcontent(0, 0, make_pstatement_empty(), NIL, e), NIL);
 
      dag_inputs(d) = CONS(dagvtx, pv, dag_inputs(d));
      vertex_list_sorted_by_entities(dag_inputs(d));
      dag_vertices(d) = CONS(dagvtx, pv, dag_vertices(d));
    }
    // a vertex may have several time the same successor: b = a + a
    dagvtx_succs(pv) = CONS(dagvtx, nv, dagvtx_succs(pv));
  }
  dag_vertices(d) = CONS(dagvtx, nv, dag_vertices(d));
 
  // ??? what about scalar deps?
}

References CONS, dag_inputs, dag_vertices, dagvtx_content, dagvtx_get_producer(), dagvtx_number(), dagvtx_succs, entity_undefined, FOREACH, gen_in_list_p(), make_dagvtx(), make_pstatement_empty(), make_vtxcontent(), NIL, pips_assert, vertex_list_sorted_by_entities(), and vtxcontent_inputs.

Referenced by compile_this_list(), dag_append_freia_call(), dag_split_connected_components(), dag_split_on_scalars(), and opencl_generate_special_kernel_ops().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_cleanup_other_statements()

void dag_cleanup_other_statements

(

dag

d

)

remove unneeded statements? you must know they are really un-needed!

Definition at line 2191 of file dag-utils.c.

{
  set toremove = set_make(set_pointer);
 
  FOREACH(dagvtx, v, dag_vertices(d))
    if (dagvtx_other_stuff_p(v))
      set_add_element(toremove, toremove, v);
 
  SET_FOREACH(dagvtx, vr, toremove)
    dag_remove_vertex(d, vr);
}

References dag_remove_vertex(), dag_vertices, dagvtx_other_stuff_p(), FOREACH, set_add_element(), SET_FOREACH, set_make(), and set_pointer.

Referenced by compile_this_list(), dag_split_connected_components(), dag_split_on_scalars(), and mppa_dag_split().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_computable_vertices()

list dag_computable_vertices	(	dag	d,
		const set	computed,
		const set	maybe,
		const set	currents
	)

return the vertices which may be computed from the list of available images, excluding vertices in exclude.

return a list for determinism.

Parameters

d	is the considered full dag
computed	holds all previously computed vertices
currents	holds those in the current pipeline @params maybe holds vertices with live images of dagvtx

Parameters

computed	omputed
maybe	aybe
currents	urrents

Definition at line 2306 of file dag-utils.c.

{
  list computable = NIL;
  set local_currents = set_make(set_pointer);
  set not_computed = set_make(set_pointer);
  set not_computed_before = set_make(set_pointer);
 
  set_assign(local_currents, currents);
 
  FOREACH(dagvtx, v, dag_vertices(d))
    if (!set_belong_p(computed, v))
      set_add_element(not_computed, not_computed, v);
 
  // hmmm... should reverse the list to handle implicit dependencies?
  // where, there is an assert() to check that it does not happen.
  list lv = gen_nreverse(gen_copy_seq(dag_vertices(d)));
 
  FOREACH(dagvtx, v, lv)
  {
    if (set_belong_p(computed, v))
      continue;
 
    if (dagvtx_other_stuff_p(v))
    {
      // a vertex with other stuff is assimilated to the pipeline
      // as soon as its dependences are fullfilled.
      // I have a problem here... I really need use_defs?
      if (all_previous_stats_with_deps_are_computed(d, computed, v))
      {
        computable = CONS(dagvtx, v, computable);
        set_add_element(local_currents, local_currents, v);
        set_del_element(not_computed, not_computed, v);
      }
    }
    else // we have an image computation
    {
      list preds = dag_vertex_preds(d, v);
      pips_debug(8, "%d predecessors to %" _intFMT "\n",
                 (int) gen_length(preds), dagvtx_number(v));
 
      // build subset of "not computed" which should occur before v
      // from the initial sequence point of view
      set_clear(not_computed_before);
      SET_FOREACH(dagvtx, vnc, not_computed)
      {
        if (dagvtx_number(vnc)<dagvtx_number(v))
          set_add_element(not_computed_before, not_computed_before, vnc);
      }
 
      if(// no scalar dependencies in the current pipeline
        !any_scalar_dep(v, local_currents) &&
        // or in the future of the graph
        !any_scalar_dep(v, not_computed_before) &&
        // and image dependencies are fulfilled.
        list_in_set_p(preds, maybe))
      {
        computable = CONS(dagvtx, v, computable);
        // we do not want deps with other currents considered!
        set_add_element(local_currents, local_currents, v);
        set_del_element(not_computed, not_computed, v);
      }
 
      gen_free_list(preds), preds = NIL;
    }
 
    // update availables: not needed under assert for no img reuse.
    // if (vtxcontent_out(c)!=entity_undefined)
    //  set_del_element(avails, avails, vtxcontent_out(c));
  }
 
  // cleanup
  set_free(local_currents);
  set_free(not_computed);
  set_free(not_computed_before);
  gen_free_list(lv);
  return computable;
}

References _intFMT, all_previous_stats_with_deps_are_computed(), any_scalar_dep(), CONS, dag_vertex_preds(), dag_vertices, dagvtx_number(), dagvtx_other_stuff_p(), FOREACH, gen_copy_seq(), gen_free_list(), gen_length(), gen_nreverse(), list_in_set_p(), NIL, pips_debug, set_add_element(), set_assign(), set_belong_p(), set_clear(), set_del_element(), SET_FOREACH, set_free(), set_make(), and set_pointer.

Referenced by dag_split_on_scalars(), dag_terapix_measures(), and opencl_merge_and_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_computation_count()

int dag_computation_count

(

const dag

d

)

return the number of actual operations in dag d.

may be zero if only input vertices remain in the dag after optimizations.

Definition at line 665 of file dag-utils.c.

{
  int count = 0;
  FOREACH(dagvtx, v, dag_vertices(d))
    if (dagvtx_number(v)!=0)
      count++;
  return count;
}

References count, dag_vertices, dagvtx_number(), and FOREACH.

Referenced by dag_split_on_scalars().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_compute_outputs()

void dag_compute_outputs	(	dag	d,
		const hash_table	occs,
		const set	output_images,
		const list	ld,
		bool	inloop
	)

(re)compute the list of GLOBAL input & output images for this dag ??? BUG the output is rather an approximation should rely on used defs or out effects for the underlying sequence.

however, the status of chains and effects on C does not allow it at the time. again after a look at DG (FC 08/08/2011)

Parameters

d	dag to consider
occs	statement image occurences, may be NULL
output_images	images that are output, may be NULL
ld	list of some other dags, possibly NIL

Parameters

occs	ccs
output_images	utput_images
ld	d
inloop	nloop

Definition at line 2073 of file dag-utils.c.

{
  pips_debug(4, "inloop=%s\n", bool_to_string(inloop));
 
  set outvars = set_make(set_pointer);
  set outs = set_make(set_pointer);
  set toremove = set_make(set_pointer);
  set stats = dag_stats(d);
 
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    pips_debug(8, "considering vertex %" _intFMT "\n", dagvtx_number(v));
    vtxcontent c = dagvtx_content(v);
    // skip special input nodes...
    if (dagvtx_number(v)!=0)
    {
      // get entity produced by vertex
      entity out = vtxcontent_out(c);
 
      pips_debug(8, "entity is %s\n", safe_entity_name(out));
 
      if (// we have an image
          out!=entity_undefined &&
          // it is not already an output
          !set_belong_p(outvars, out) &&
          // and either...
          (// this image is used as output (typically a tx call)
           (output_images && set_belong_p(output_images, out)) ||
           // no successors to this vertex BUT it is used somewhere (else?)
           (!dagvtx_succs(v) && other_significant_uses(out, occs, stats)) ||
           // all non-empty successors are measures?!
           (dagvtx_succs(v) && all_mesures_p(dagvtx_succs(v))) ||
           // new function parameter not yet an output
           (formal_parameter_p(out) && !set_belong_p(outvars, out)) ||
           // hmmm... yet another hack for freia_61
           (variable_used_as_later_input(out, ld)) ||
           // an output image is only reused by this dag within a loop?
           (inloop && dag_image_is_an_input(d, out))))
      {
        pips_debug(7, "appending %" _intFMT "\n", dagvtx_number(v));
        set_add_element(outvars, outvars, out);
        set_add_element(outs, outs, v);
      }
    }
    else
    {
      // ??? this aborts with terapix...
      // pips_assert("is an input vertex", gen_in_list_p(v, dag_inputs(d)));
      if (!dagvtx_succs(v))
        set_add_element(toremove, toremove, v);
    }
  }
 
  ifdebug(8)
  {
    dag_dump(stderr, "dag_compute_outputs", d);
    set_fprint(stderr, "new outs", outs, (gen_string_func_t) dagvtx_number_str);
  }
 
  // cleanup unused node inputs
  SET_FOREACH(dagvtx, vr, toremove)
    dag_remove_vertex(d, vr);
 
  gen_free_list(dag_outputs(d));
  dag_outputs(d) = set_to_sorted_list(outs, (gen_cmp_func_t) dagvtx_ordering);
 
  // cleanup
  set_free(stats);
  set_free(outs);
  set_free(outvars);
  set_free(toremove);
}

References _intFMT, all_mesures_p(), bool_to_string(), dag_dump(), dag_image_is_an_input(), dag_outputs, dag_remove_vertex(), dag_stats(), dag_vertices, dagvtx_content, dagvtx_number(), dagvtx_number_str(), dagvtx_ordering(), dagvtx_succs, entity_undefined, FOREACH, formal_parameter_p(), gen_free_list(), ifdebug, other_significant_uses(), out, pips_debug, safe_entity_name(), set_add_element(), set_belong_p(), SET_FOREACH, set_fprint(), set_free(), set_make(), set_pointer, set_to_sorted_list(), variable_used_as_later_input(), and vtxcontent_out.

Referenced by compile_this_list(), dag_split_connected_components(), dag_split_on_scalars(), freia_build_dag(), and freia_spoc_pipeline().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_connected_component()

list dag_connected_component	(	dag	d,
		list *	plv,
		bool(*)(const dagvtx, const set, const dag)	compat
	)

extract a sublist of lv which is a connected component.

update lv so that the extracted vertices are not there. the extracted list must keep the order of the initial list!

Parameters

plv

lv

Definition at line 2939 of file dag-utils.c.

{
  ifdebug(7) {
    pips_debug(7, "entering\n");
    gen_fprint(stderr, "initial list", *plv, dagvtx_nb);
  }
 
  set connected = set_make(set_pointer);
  set extracted = set_make(set_pointer);
 
  // boostrap.
  dagvtx first = DAGVTX(CAR(*plv));
  set_add_element(extracted, extracted, first);
  set_add_element(connected, connected, first);
  set_append_list(connected, dagvtx_succs(first));
 
  bool stable = false;
  while (!stable)
  {
    stable = true;
 
    // expand thru common dag inputs
    FOREACH(dagvtx, i, dag_inputs(d))
    {
      bool merge = false;
      FOREACH(dagvtx, v, dagvtx_succs(i)) {
        if (set_belong_p(extracted, v)) {
          merge = true;
          break;
        }
      }
      if (merge)
        set_append_list(connected, dagvtx_succs(i));
    }
 
    // expand with new vertices from the list
    FOREACH(dagvtx, v, *plv)
    {
      if (!set_belong_p(extracted, v) && (!compat || compat(v, extracted, d)))
      {
        // do we need to extract v?
        bool connect =  set_belong_p(connected, v);
        if (!connect) {
          FOREACH(dagvtx, s, dagvtx_succs(v))
            if (set_belong_p(extracted, s)) {
              connect = true;
              break;
            }
        }
        if (connect) {
          stable = false;
          set_add_element(extracted, extracted, v);
          set_add_element(connected, connected, v);
          set_append_list(connected, dagvtx_succs(v));
        }
      }
    }
  }
 
  // split initial list
  list lnew = NIL, lold = NIL;
  FOREACH(dagvtx, v, *plv)
  {
    if (set_belong_p(extracted, v))
      lnew = CONS(dagvtx, v, lnew);
    else
      lold = CONS(dagvtx, v, lold);
  }
  lnew = gen_nreverse(lnew);
  gen_free_list(*plv);
  *plv = gen_nreverse(lold);
 
  set_free(connected);
  set_free(extracted);
 
  ifdebug(7) {
    pips_debug(7, "exiting\n");
    gen_fprint(stderr, "final list", *plv, dagvtx_nb);
    gen_fprint(stderr, "returned", lnew, dagvtx_nb);
  }
 
  return lnew;
}

References CAR, CONS, dag_inputs, DAGVTX, dagvtx_nb(), dagvtx_succs, FOREACH, gen_fprint(), gen_free_list(), gen_nreverse(), ifdebug, NIL, pips_debug, set_add_element(), set_append_list(), set_belong_p(), set_free(), set_make(), and set_pointer.

Referenced by dag_split_connected_components(), and opencl_merge_and_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_consistency_asserts()

void dag_consistency_asserts

(

dag

d

)

do some consistency checking...

Definition at line 531 of file dag-utils.c.

{
  FOREACH(dagvtx, v, dag_inputs(d))
    pips_assert("vertex once in inputs", gen_occurences(v, dag_inputs(d))==1);
 
  set variable_seen = set_make(set_pointer);
  FOREACH(dagvtx, v, dag_inputs(d))
  {
    entity image = dagvtx_image(v);
    // fprintf(stdout, " - image %s\n", entity_name(image));
    pips_assert("image is defined", image!=entity_undefined);
    pips_assert("variable only once in inputs",
                !set_belong_p(variable_seen, image));
    set_add_element(variable_seen, variable_seen, image);
  }
  set_free(variable_seen);
}

References dag_inputs, dagvtx_image(), entity_undefined, FOREACH, gen_occurences(), pips_assert, set_add_element(), set_belong_p(), set_free(), set_make(), and set_pointer.

Referenced by freia_trpx_compile_one_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_dot()

void dag_dot	(	FILE *	out,
		const string	what,
		const dag	d,
		const list	lb,
		const list	la
	)

output dag in dot format, for debug or show

Parameters

out,append	to this file
what,name	of dag
d,dag	to output

Parameters

out	ut
what	hat
lb	b
la	a

Definition at line 409 of file dag-utils.c.

{
  // compute and show dag statistics
  // count image, copy, scalar operations
  int niops = 0, ncops = 0, nsops = 0;
  FOREACH(dagvtx, op, dag_vertices(d))
  {
    if (dagvtx_is_copy_p(op)) ncops++;
    else if (!gen_in_list_p(op, dag_inputs(d))) {
      if (dagvtx_other_stuff_p(op)) nsops++;
      else niops++;
    }
  }
 
  fprintf(out, "// DAG \"%s\": "
          // input, output, computation, scalar vertices
          "#i=%d #o=%d #c=%d #s=%d "
          // copies: internal, before, after
          "#I=%d #B=%d #A=%d\n",
          what,
          (int) gen_length(dag_inputs(d)), (int) gen_length(dag_outputs(d)),
          niops, nsops, ncops, (int) gen_length(lb), (int) gen_length(la));
 
  // start graph
  fprintf(out, "digraph \"%s\" {\n", what);
 
  // collect set of input images
  set inputs = set_make(set_pointer);
  FOREACH(dagvtx, i, dag_inputs(d))
  {
    entity img = dagvtx_image(i);
    if (img && img!=entity_undefined)
      set_add_element(inputs, inputs, img);
  }
 
  // first, declare inputs and outputs as circles
  dagvtx_list_dot(out, "inputs", dag_inputs(d), NULL);
  dagvtx_list_dot(out, "outputs", dag_outputs(d), inputs);
 
  // second, show computations
  fprintf(out, "  // computation vertices\n");
  FOREACH(dagvtx, vx, dag_vertices(d))
  {
    dagvtx_dot(out, d, vx);
    vtxcontent c = dagvtx_content(vx);
 
    // outputs arcs for vx when the result is extracted
    if (gen_in_list_p(vx, dag_outputs(d)))
    {
      entity img = vtxcontent_out(c);
      dagvtx_dot_node(out, "  ", vx);
      fprintf(out, " -> \"%s%s\";\n",
              entity_dot_name(img), set_belong_p(inputs, img)? "'": "");
    }
  }
 
  // handle external copies after the computation
  if (lb)
  {
    fprintf(out, "\n  // external before copies: %d\n", (int) gen_length(lb));
    dagvtx_copy_list_dot(out, lb, inputs);
  }
 
  if (la)
  {
    fprintf(out, "\n  // external after copies: %d\n", (int) gen_length(la));
    dagvtx_copy_list_dot(out, la, inputs);
  }
 
  fprintf(out, "}\n");
 
  set_free(inputs);
}

References dag_inputs, dag_outputs, dag_vertices, dagvtx_content, dagvtx_copy_list_dot(), dagvtx_dot(), dagvtx_dot_node(), dagvtx_image(), dagvtx_is_copy_p(), dagvtx_list_dot(), dagvtx_other_stuff_p(), entity_dot_name(), entity_undefined, FOREACH, fprintf(), gen_in_list_p(), gen_length(), out, set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, and vtxcontent_out.

Referenced by dag_dot_dump().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_dot_dump()

void dag_dot_dump	(	const	string,
		const	string,
		const	dag,
		const	list,
		const	list
	)

generate a "dot" format from a dag to a file.

Parameters

string	odule
string	ame
list	b
list	a

Definition at line 488 of file dag-utils.c.

{
  // build file name
  string src_dir = db_get_directory_name_for_module(module);
  string fn = strdup(cat(src_dir, "/", name, DOT_SUFFIX, NULL));
  free(src_dir);
 
  FILE * out = safe_fopen(fn, "w");
  fprintf(out, "// graph for dag \"%s\" of module \"%s\" in dot format\n",
    name, module);
  dag_dot(out, name, d, lb, la);
  safe_fclose(out, fn);
  free(fn);
}

References cat, dag_dot(), db_get_directory_name_for_module(), DOT_SUFFIX, fprintf(), free(), module, out, safe_fclose(), safe_fopen(), and strdup().

Referenced by dag_dot_dump_prefix(), freia_trpx_compile_one_dag(), opencl_compile_mergeable_dag(), and opencl_merge_and_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_dot_dump_prefix()

void dag_dot_dump_prefix	(	const	string,
		const	string,
		int	number,
		const	dag,
		const	list,
		const	list
	)

Parameters

string	odule
string	refix
number	umber
list	b
list	a

Definition at line 504 of file dag-utils.c.

{
  string name = strdup(cat(prefix, i2a(number), NULL));
  dag_dot_dump(module, name, d, lb, la);
  free(name);
}

References cat, dag_dot_dump(), free(), i2a(), module, prefix, and strdup().

Referenced by freia_aipo_compile_calls(), freia_build_dag(), 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:

dag_dump()

void dag_dump	(	FILE *	out,
		const	string,
		const	dag
	)

for dag debug

Parameters

out	ut
string	hat

Definition at line 212 of file dag-utils.c.

{
  fprintf(out, "dag '%s' (%p) %"_intFMT" vertices:\n",
          what, d, gen_length(dag_vertices(d)));
 
  dagvtx_nb_dump(out, "inputs", dag_inputs(d));
  dagvtx_nb_dump(out, "outputs", dag_outputs(d));
  fprintf(out, "\n");
 
  FOREACH(dagvtx, vx, dag_vertices(d)) {
    dagvtx_dump(out, NULL, vx);
    fprintf(out, "\n");
  }
 
  fprintf(out, "\n");
}

References _intFMT, dag_inputs, dag_outputs, dag_vertices, dagvtx_dump(), dagvtx_nb_dump(), FOREACH, fprintf(), gen_length(), and out.

Referenced by dag_compute_outputs(), dag_split_on_scalars(), freia_build_dag(), freia_dag_optimize(), freia_trpx_compile_one_dag(), mppa_compile_dag(), opencl_compile_mergeable_dag(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_fix_image_reuse()

list dag_fix_image_reuse	(	dag	d,
		hash_table	init,
		const hash_table	occs
	)

fix intermediate image reuse in dag

Returns

new image entities to be added to declarations

Parameters

init	nit
occs	ccs

Definition at line 2779 of file dag-utils.c.

{
  list images = NIL;
  set seen = set_make(set_pointer);
 
  // dag vertices are assumed to be in reverse statement order,
  // so that last write is seen first and is kept by default
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    entity img = dagvtx_image(v);
    if (!img || img==entity_undefined)
      continue;
 
    if (set_belong_p(seen, img) &&
        // but take care of image reuse, we must keep input images!
        !gen_in_list_p(v, dag_inputs(d)))
    {
      entity new_img = new_local_image_variable(img, occs);
      switch_image_variable(v, img, new_img);
      images = CONS(entity, new_img, images);
      // keep track of new->old image mapping, to reverse it latter eventually
      hash_put(init, new_img, img);
    }
    set_add_element(seen, seen, img);
  }
 
  set_free(seen);
  return images;
}

References CONS, dag_inputs, dag_vertices, dagvtx_image(), entity_undefined, FOREACH, gen_in_list_p(), hash_put(), init, new_local_image_variable(), NIL, seen, set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, and switch_image_variable().

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:

dag_no_image_operation()

bool dag_no_image_operation

(

dag

d

)

tell whether we have something to do with images ??? hmmm...

what about vol(cst_img()) ?

Definition at line 2500 of file dag-utils.c.

{
  return !dag_inputs(d) && !dag_outputs(d);
}

References dag_inputs, and dag_outputs.

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

Here is the caller graph for this function:

dag_remove_vertex()

void dag_remove_vertex	(	dag	d,
		const dagvtx	v
	)

remove vertex v from dag d.

if v isx a used computation vertex, it is substituted by an input vertex.

Definition at line 570 of file dag-utils.c.

{
  // hmmm...
  // pips_assert("vertex is in dag", gen_in_list_p(v, dag_vertices(d)));
  if (!gen_in_list_p(v, dag_vertices(d)))
    // already done???
    return;
 
  if (dagvtx_succs(v))
  {
    // the ouput of the removed operation becomes an input to the dag
    entity var = vtxcontent_out(dagvtx_content(v));
    pips_assert("some variable", var!=entity_undefined);
    dagvtx input =
      make_dagvtx(make_vtxcontent(0, 0, make_pstatement_empty(), NIL, var),
                  gen_copy_seq(dagvtx_succs(v)));
    dag_inputs(d) = CONS(dagvtx, input, dag_inputs(d));
    dag_vertices(d) = CONS(dagvtx, input, dag_vertices(d));
    vertex_list_sorted_by_entities(dag_inputs(d));
  }
 
  // remove from all vertex lists
  gen_remove(&dag_vertices(d), v);
  gen_remove(&dag_inputs(d), v);
  gen_remove(&dag_outputs(d), v);
 
  // remove from successors of any ???
  FOREACH(dagvtx, dv, dag_vertices(d))
    gen_remove(&dagvtx_succs(dv), v);
 
  // cleanup input list
  dag_remove_unused_inputs(d);
 
  // unlink vertex itself
  gen_free_list(dagvtx_succs(v)), dagvtx_succs(v) = NIL;
 
  ifdebug(8) gen_context_recurse(d, v, dagvtx_domain, gen_true2, check_removed);
}

References check_removed(), CONS, dag_inputs, dag_outputs, dag_remove_unused_inputs(), dag_vertices, dagvtx_content, dagvtx_domain, dagvtx_succs, entity_undefined, FOREACH, gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_in_list_p(), gen_remove(), gen_true2(), ifdebug, input(), make_dagvtx(), make_pstatement_empty(), make_vtxcontent(), NIL, pips_assert, vertex_list_sorted_by_entities(), and vtxcontent_out.

Referenced by dag_cleanup_other_statements(), dag_compute_outputs(), dag_split_connected_components(), dag_split_on_scalars(), freia_dag_optimize(), freia_spoc_pipeline(), freia_terapix_call(), and opencl_merge_and_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_split_connected_components()

list dag_split_connected_components	(	dag	d,
		set	output_images
	)

build connected components

Parameters

output_images

utput_images

Definition at line 3035 of file dag-utils.c.

{
  list lnd = NIL;
  list vertices = copy_vertices(dag_vertices(d));
 
  pips_debug(3, "considering %"_intFMT" vertices\n", gen_length(vertices));
  ifdebug(3)
    gen_fprint(stderr, "vertices", vertices, dagvtx_nb);
 
  while (vertices)
  {
    list cv = dag_connected_component(d, &vertices, NULL);
    pips_assert("some connected vertices", cv);
    if (!vertices) { // take remaining dag in full
      lnd = CONS(dag, d, lnd);
      break;
    }
 
    ifdebug(3) gen_fprint(stderr, "connected component", cv, dagvtx_nb);
 
    // else there seems to be an actual split...
    dag nd = make_dag(NIL, NIL, NIL);
    cv = gen_nreverse(cv); // ??? they must be introduced in reverse order?
    FOREACH(dagvtx, v, cv)
      dag_append_vertex(nd, copy_dagvtx_norec(v));
    dag_compute_outputs(nd, NULL, output_images, NIL, false);
    dag_cleanup_other_statements(nd);
    // ???
    freia_hack_fix_global_ins_outs(d, nd);
    lnd = CONS(dag, nd, lnd);
 
    // cleanup other dag for next round
    FOREACH(dagvtx, v, cv)
      dag_remove_vertex(d, v);
    dag_compute_outputs(d, NULL, output_images, NIL, false);
    dag_cleanup_other_statements(d);
  }
 
  pips_debug(3, "found %"_intFMT" connected components\n", gen_length(lnd));
  return gen_nreverse(lnd);
}

References _intFMT, CONS, copy_dagvtx_norec(), copy_vertices(), dag_append_vertex(), dag_cleanup_other_statements(), dag_compute_outputs(), dag_connected_component(), dag_remove_vertex(), dag_vertices, dagvtx_nb(), FOREACH, freia_hack_fix_global_ins_outs(), gen_fprint(), gen_length(), gen_nreverse(), ifdebug, make_dag(), NIL, pips_assert, and pips_debug.

Here is the call graph for this function:

dag_split_on_scalars()

list dag_split_on_scalars	(	const dag	initial,
		bool(*)(const dagvtx)	alone_only,
		dagvtx(*)(const list, bool)	choose_vertex,
		gen_cmp_func_t	priority,
		void(*)(const dag)	priority_update,
		const set	output_images
	)

split a dag on scalar dependencies only, with a greedy heuristics.

Parameters

initial	dag to split
alone_only	whether to keep it alone (for non implemented cases)
choose_vertex	chose a vertex from computable ones, may be NULL
priority	how to prioritize computable vertices
priority_update	stuff to help prioritization

Returns

a list of sub-dags, some of which may contain no image operations For terapix, this pass also decides the schedule of image operations, with the aim or reducing the number of necessary imagelets, so as to maximise imagelet size.

Parameters

initial	nitial
priority	riority
output_images	utput_images

Definition at line 2823 of file dag-utils.c.

{
  if (!single_image_assignement_p(initial))
    // well, it should work most of the time, so only a warning
    pips_user_warning("still some image reuse...\n");
 
  // ifdebug(1) pips_assert("initial dag ok", dag_consistent_p(initial));
  // if everything was removed by optimizations, there is nothing to do.
  if (dag_computation_count(initial)==0) return NIL;
 
  // work on a copy of the dag.
  dag dall = copy_dag(initial);
  list ld = NIL;
  set
    // current set of vertices to group
    current = set_make(set_pointer),
    // all vertices which are considered computed
    computed = set_make(set_pointer);
 
  do
  {
    list lcurrent = NIL, computables;
    set_clear(current);
    set_clear(computed);
    set_assign_list(computed, dag_inputs(dall));
 
    // GLOBAL for sorting
    if (priority_update) priority_update(dall);
 
    // transitive closure
    while ((computables =
            dag_computable_vertices(dall, computed, computed, current)))
    {
      ifdebug(7) {
        FOREACH(dagvtx, v, computables)
          dagvtx_dump(stderr, "computable", v);
      }
 
      // sort, mostly for determinism
      gen_sort_list(computables, priority);
 
      // choose one while building the schedule?
      dagvtx choice = choose_vertex?
        choose_vertex(computables, lcurrent? true: false):
        DAGVTX(CAR(computables));
      gen_free_list(computables), computables = NIL;
 
      ifdebug(7)
        dagvtx_dump(stderr, "choice", choice);
 
      // do not add if not alone
      if (alone_only && alone_only(choice) && lcurrent)
        break;
 
      set_add_element(current, current, choice);
      set_add_element(computed, computed, choice);
      lcurrent = gen_nconc(lcurrent, CONS(dagvtx, choice, NIL));
 
      // getout if was alone
      if (alone_only && alone_only(choice))
        break;
    }
 
    // is there something?
    if (lcurrent)
    {
      // build extracted dag
      dag nd = make_dag(NIL, NIL, NIL);
      FOREACH(dagvtx, v, lcurrent)
      {
        pips_debug(7, "extracting node %" _intFMT "\n", dagvtx_number(v));
        dag_append_vertex(nd, copy_dagvtx_norec(v));
      }
      dag_compute_outputs(nd, NULL, output_images, NIL, false);
      dag_cleanup_other_statements(nd);
 
      ifdebug(7) {
        // dag_dump(stderr, "updated dall", dall);
        dag_dump(stderr, "pushed dag", nd);
      }
 
      // ??? hmmm... should not be needed?
      freia_hack_fix_global_ins_outs(initial, nd);
 
      // update global list of dags to return.
      ld = CONS(dag, nd, ld);
 
      // cleanup full dag for next round
      FOREACH(dagvtx, w, lcurrent)
        dag_remove_vertex(dall, w);
 
      gen_free_list(lcurrent), lcurrent = NIL;
    }
  }
  while (set_size(current));
 
  free_dag(dall);
  return gen_nreverse(ld);
}

References _intFMT, CAR, choice, CONS, copy_dag(), copy_dagvtx_norec(), current, dag_append_vertex(), dag_cleanup_other_statements(), dag_computable_vertices(), dag_computation_count(), dag_compute_outputs(), dag_dump(), dag_inputs, dag_remove_vertex(), DAGVTX, dagvtx_dump(), dagvtx_number(), FOREACH, free_dag(), freia_hack_fix_global_ins_outs(), gen_free_list(), gen_nconc(), gen_nreverse(), gen_sort_list(), ifdebug, make_dag(), NIL, pips_debug, pips_user_warning, set_add_element(), set_assign_list(), set_clear(), set_make(), set_pointer, set_size(), and single_image_assignement_p().

Referenced by 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:

dag_statements()

void dag_statements	(	set	stats,
		const	dag
	)

build the set of actual statements in d

Parameters

stats

tats

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

{
  set_clear(stats);
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    statement s = dagvtx_statement(v);
    if (s) set_add_element(stats, stats, s);
  }
}

References dag_vertices, dagvtx_statement(), FOREACH, set_add_element(), and set_clear().

Referenced by 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:

dag_vertex_preds()

list dag_vertex_preds	(	const dag	d,
		const dagvtx	target
	)

return target predecessor vertices as a list.

the same predecessor appears twice in b = a+a build them in call order! ??? maybe I should build a cache for performance, but I would have to keep track of when dags are modified...

Parameters

target

arget

Definition at line 680 of file dag-utils.c.

{
  pips_debug(8, "building predecessors of %"_intFMT"\n", dagvtx_number(target));
  list inputs = vtxcontent_inputs(dagvtx_content(target));
  int nins = (int) gen_length(inputs);
  entity first_img = NULL, second_img = NULL;
  if (nins>=1) first_img = ENTITY(CAR(inputs));
  if (nins==2) second_img = ENTITY(CAR(CDR(inputs)));
  dagvtx first_v = NULL, second_v = NULL;
 
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    if (v!=target && gen_in_list_p(target, dagvtx_succs(v)))
    {
      if (dagvtx_image(v)==first_img)
        first_v = v;
      if (dagvtx_image(v)==second_img)
        second_v = v;
    }
  }
 
  list preds = NIL;
  if (second_v) preds = CONS(dagvtx, second_v, NIL);
  if (first_v) preds = CONS(dagvtx, first_v, preds);
  return preds;
}

References _intFMT, CAR, CDR, CONS, dag_vertices, dagvtx_content, dagvtx_image(), dagvtx_number(), dagvtx_succs, ENTITY, FOREACH, gen_in_list_p(), gen_length(), int, NIL, pips_debug, and vtxcontent_inputs.

Referenced by compute_dead_vertices(), dag_computable_vertices(), dag_simplify(), freia_dag_optimize(), image_is_needed(), mppa_compile_dag(), mppa_dag_split(), opencl_compile_mergeable_dag(), opencl_merge_and_compile(), sc_delimiter(), sc_get_port_id(), update_erosions(), and vertex_mergeable_p().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_compact_operation()

string dagvtx_compact_operation

(

const

dagvtx

)

Definition at line 140 of file dag-utils.c.

{
  if (v==NULL) return "null";
  int index = vtxcontent_opid(dagvtx_content(v));
  const freia_api_t * api = get_freia_api(index);
  return api->compact_name;
}

References freia_api_t::compact_name, dagvtx_content, get_freia_api(), and vtxcontent_opid.

Referenced by compatible_reduction_operation(), dagvtx_dot(), dagvtx_dot_node(), and dagvtx_dot_node_sb().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_dump()

void dagvtx_dump	(	FILE *	out,
		const	string,
		const	dagvtx
	)

for dag debug.

Parameters

out	ut
string	ame

Definition at line 186 of file dag-utils.c.

{
  if (!v) {
    fprintf(out, "vertex %s is NULL\n", name? name: "");
    return;
  }
  fprintf(out, "vertex %s %" _intFMT " %s (%p)\n",
    name? name: "", dagvtx_number(v), dagvtx_operation(v), v);
  dagvtx_nb_dump(out, "  succs", dagvtx_succs(v));
  vtxcontent c = dagvtx_content(v);
  statement s = dagvtx_statement(v);
  fprintf(out,
    "  optype: %s\n"
    "  opid: %" _intFMT "\n"
    "  source: %" _intFMT "/%" _intFMT "\n",
    what_operation(vtxcontent_optype(c)),
    vtxcontent_opid(c),
    s? statement_number(s): 0,
    s? statement_ordering(s): 0);
  entity_list_dump(out, "  inputs", vtxcontent_inputs(c));
  fprintf(out, "  output: %s\n", safe_entity_name(vtxcontent_out(c)));
  // to be continued...
}

References _intFMT, dagvtx_content, dagvtx_nb_dump(), dagvtx_number(), dagvtx_operation(), dagvtx_statement(), dagvtx_succs, entity_list_dump(), fprintf(), out, safe_entity_name(), statement_number, statement_ordering, vtxcontent_inputs, vtxcontent_opid, vtxcontent_optype, vtxcontent_out, and what_operation().

Referenced by dag_dump(), dag_split_on_scalars(), dagvtx_terapix_priority(), and switch_vertex_to_a_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_function_name()

string dagvtx_function_name

(

const

dagvtx

)

Definition at line 126 of file dag-utils.c.

{
  if (v==NULL) return "null";
  int index = vtxcontent_opid(dagvtx_content(v));
  const freia_api_t * api = get_freia_api(index);
  return api->function_name;
}

References dagvtx_content, freia_api_t::function_name, get_freia_api(), and vtxcontent_opid.

Referenced by dagvtx_operation(), and freia_aipo_count().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_get_producer()

dagvtx dagvtx_get_producer	(	const dag	d,
		const dagvtx	sink,
		const entity	e,
		_int	before_number
	)

return (last) producer of image e for vertex sink, or NULL if none found.

this is one of the two predecessors of sink.

Parameters

sink	ink
before_number	efore_number

Definition at line 156 of file dag-utils.c.

{
  pips_assert("some image", e!=entity_undefined);
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    vtxcontent c = dagvtx_content(v);
    pips_debug(8, "%"_intFMT" pred of %"_intFMT"?\n",
               dagvtx_number(v), dagvtx_number(sink));
    // they may have been reversed ordered when used to append a vertex
    if (before_number>0 && dagvtx_number(v)>0 && dagvtx_number(v)>before_number)
      continue;
    // the image may be kept within a pipe
    if (vtxcontent_out(c)==e &&
        (sink==NULL || gen_in_list_p(sink, dagvtx_succs(v))))
      return v;
  }
  return NULL; // it is an external parameter?
}

References _intFMT, dag_vertices, dagvtx_content, dagvtx_number(), dagvtx_succs, entity_undefined, FOREACH, gen_in_list_p(), pips_assert, pips_debug, and vtxcontent_out.

Referenced by dag_append_vertex(), dag_vertex_pred_imagelets(), freia_dag_optimize(), and unlink_copy_vertex().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_image()

entity dagvtx_image

(

const

dagvtx

)

return the produced image or NULL

Definition at line 82 of file dag-utils.c.

{
  vtxcontent c = dagvtx_content(v);
  return (vtxcontent_out(c) != entity_undefined)? vtxcontent_out(c): NULL;
}

References dagvtx_content, entity_undefined, and vtxcontent_out.

Referenced by dag_consistency_asserts(), dag_dot(), dag_fix_image_reuse(), dag_image_is_an_input(), dag_simplify(), dag_vertex_preds(), init_op_schedule(), mppa_compile_dag(), mppa_helper_args_params(), sc_delimiter(), switch_vertex_to_a_copy(), and variable_used_as_later_input().

Here is the caller graph for this function:

dagvtx_is_measurement_p()

bool dagvtx_is_measurement_p

(

const

dagvtx

)

returns whether the vertex is an image measurement operation.

Definition at line 623 of file dag-utils.c.

{
  vtxcontent c = dagvtx_content(v);
  const freia_api_t * api = get_freia_api(vtxcontent_opid(c));
  return strncmp(api->function_name, AIPO "global_", strlen(AIPO "global_"))==0;
}

References AIPO, dagvtx_content, freia_api_t::function_name, get_freia_api(), and vtxcontent_opid.

Referenced by all_vertices_are_copies_or_measures_p(), freia_dag_optimize(), mppa_compile_dag(), mppa_helper_args_params(), opencl_merge_and_compile(), sc_delimiter(), sigmac_params_decl(), and vertex_mergeable_p().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_nb_dump()

void dagvtx_nb_dump	(	FILE *	out,
		const	string,
		const	list
	)

Parameters

out	ut
string	hat

Definition at line 176 of file dag-utils.c.

{
  fprintf(out, "%s: ", what);
  FOREACH(dagvtx, v, l)
    fprintf(out, " %" _intFMT ",", dagvtx_number(v));
  fprintf(out, "\n");
}

References _intFMT, dagvtx_number(), FOREACH, fprintf(), and out.

Referenced by dag_dump(), dagvtx_dump(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_number()

_int dagvtx_number

(

const dagvtx

v

)

returns the vertex number, i.e.

the underlying statement number.

Definition at line 98 of file dag-utils.c.

{
  if (v==NULL) return 0;
  pstatement source = vtxcontent_source(dagvtx_content(v));
  if (pstatement_statement_p(source))
  {
    statement s = pstatement_statement(source);
    return s? statement_number(s): 0;
  }
  else
    return 0;
}

References dagvtx_content, pstatement_statement, pstatement_statement_p, statement_number, and vtxcontent_source.

Referenced by all_previous_stats_with_deps_are_computed(), any_scalar_dep(), comment(), copy_vertices(), dag_append_vertex(), dag_computable_vertices(), dag_computation_count(), dag_compute_outputs(), dag_split_on_scalars(), dag_vertex_preds(), dagvtx_dot(), dagvtx_dot_node(), dagvtx_dot_node_sb(), dagvtx_dump(), dagvtx_get_producer(), dagvtx_nb(), dagvtx_nb_dump(), dagvtx_number_str(), dagvtx_opencl_priority(), dagvtx_ordering(), dagvtx_spoc_priority(), dagvtx_terapix_priority(), dagvtx_to_string(), find_twin_vertex(), freia_dag_optimize(), freia_hack_fix_global_ins_outs(), freia_spoc_pipeline(), generate_wiring(), image_is_needed(), is_consummed_by_vertex(), mppa_compile_dag(), opencl_compile_mergeable_dag(), opencl_generate_special_kernel_ops(), opencl_merge_and_compile(), opencl_mergeable_p(), pixel_name(), print_op_schedule(), sc_delimiter(), substitute_image_in_statement(), switch_vertex_to_a_copy(), switch_vertex_to_assign(), unlink_copy_vertex(), and where_to_perform_operation().

Here is the caller graph for this function:

dagvtx_number_str()

string dagvtx_number_str

(

const

dagvtx

)

Definition at line 111 of file dag-utils.c.

{
  return i2a(dagvtx_number(v));
}

References dagvtx_number(), and i2a().

Referenced by any_scalar_dep(), dag_compute_outputs(), and opencl_merge_and_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_operation()

string dagvtx_operation

(

const

dagvtx

)

Definition at line 134 of file dag-utils.c.

{
  string op = dagvtx_function_name(v);
  return strncmp(op, AIPO, strlen(AIPO))==0? op + strlen(AIPO): op;
}

References AIPO, and dagvtx_function_name().

Referenced by comment(), dagvtx_dump(), dagvtx_spoc_priority(), dagvtx_terapix_priority(), freia_convolution_p(), generate_wiring(), mppa_compile_dag(), print_op_schedule(), sc_delimiter(), and where_to_perform_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_opid()

_int dagvtx_opid

(

const

dagvtx

)

Definition at line 121 of file dag-utils.c.

{
  return vtxcontent_opid(dagvtx_content(v));
}

References dagvtx_content, and vtxcontent_opid.

Referenced by commutative_operation_p(), freia_spoc_pipeline(), freia_terapix_call(), mppa_call_helper(), opencl_compile_mergeable_dag(), same_constant_parameters(), same_operation_p(), sc_delimiter(), and sc_get_params_values().

Here is the caller graph for this function:

dagvtx_optype()

_int dagvtx_optype

(

const

dagvtx

)

Definition at line 116 of file dag-utils.c.

{
  return vtxcontent_optype(dagvtx_content(v));
}

References dagvtx_content, and vtxcontent_optype.

Referenced by all_mesures_p(), commutative_operation_p(), dagvtx_spoc_priority(), dagvtx_terapix_priority(), freia_spoc_pipeline(), generate_wiring(), has_vtx_dynamic_params(), mppa_compile_dag(), mppa_helper_args_params(), reuse_pred_slot(), same_operation_p(), sc_delimiter(), sc_inst(), sc_kernel_compute_loop(), sc_kernel_specific_agent(), and sigmac_params_decl().

Here is the caller graph for this function:

dagvtx_ordering()

int dagvtx_ordering	(	const dagvtx *	v1,
		const dagvtx *	v2
	)

Parameters

v1	1
v2	2

Definition at line 148 of file dag-utils.c.

{
  return dagvtx_number(*v1) - dagvtx_number(*v2);
}

References dagvtx_number().

Referenced by dag_compute_outputs(), and freia_mppa_compile_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_other_stuff_p()

bool dagvtx_other_stuff_p

(

const

dagvtx

)

a vertex with a non AIPO or image related statement.

Definition at line 76 of file dag-utils.c.

{
  return vtxcontent_optype(dagvtx_content(v))==spoc_type_oth;
}

References dagvtx_content, spoc_type_oth, and vtxcontent_optype.

Referenced by choose_opencl_vertex(), dag_cleanup_other_statements(), dag_computable_vertices(), dag_dot(), dagvtx_dot(), freia_opencl_compile_calls(), and freia_terapix_call().

Here is the caller graph for this function:

dagvtx_statement()

statement dagvtx_statement

(

const

dagvtx

)

return statement if any, or NULL (for input nodes).

Definition at line 56 of file dag-utils.c.

{
  pstatement ps = vtxcontent_source(dagvtx_content(v));
  return pstatement_statement_p(ps)? pstatement_statement(ps): NULL;
}

References dagvtx_content, pstatement_statement, pstatement_statement_p, and vtxcontent_source.

Referenced by all_previous_stats_with_deps_are_computed(), any_scalar_dep(), dag_normalize(), dag_statements(), dag_stats(), dagvtx_dot(), dagvtx_dump(), freia_compile(), migrate_statements(), mppa_call_helper(), opencl_generate_special_kernel_ops(), same_constant_parameters(), sc_delimiter(), switch_image_variable(), and switch_vertex_to_assign().

Here is the caller graph for this function:

dagvtx_to_string()

string dagvtx_to_string

(

const

dagvtx

)

dag-utils.c

Definition at line 49 of file dag-utils.c.

{
  return i2a(dagvtx_number(v));
}

References dagvtx_number(), and i2a().

Here is the call graph for this function:

entity_freia_api_p()

bool entity_freia_api_p

(

const

entity

)

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:

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_compile_calls()

list freia_aipo_compile_calls	(	string	module,
		dag	fulld,
		list	ls,
		const	hash_table,
		hash_table	exchanges,
		int	number
	)

freia_aipo.c

Parameters

module	odule
fulld	ulld
ls	s
hash_table	ccs
exchanges	xchanges
number	umber

Definition at line 48 of file freia_aipo.c.

{
  pips_debug(3, "considering %d statements\n", (int) gen_length(ls));
  pips_assert("some statements", ls);
 
  // about aipo statistics: no helper file to put them...
 
  // handle intermediate images
  hash_table init = hash_table_make(hash_pointer, 0);
  list new_images = dag_fix_image_reuse(fulld, init, occs);
 
  // optimize dag
  list added_before = NIL, added_after = NIL;
  freia_dag_optimize(fulld, exchanges, &added_before, &added_after);
 
  // dump final optimised dag
  dag_dot_dump_prefix(module, "dag_cleaned_", number, fulld,
                      added_before, added_after);
 
  // now may put actual allocations, which messes up statement numbers
  list reals =
    freia_allocate_new_images_if_needed(ls, new_images, occs, init, NULL);
 
  // ??? should it be NIL because it is not useful in AIPO->AIPO?
  freia_insert_added_stats(ls, added_before, true);
  added_before = NIL;
  freia_insert_added_stats(ls, added_after, false);
  added_after = NIL;
 
  // cleanup
  gen_free_list(new_images);
  hash_table_free(init);
 
  return reals;
}

References dag_dot_dump_prefix(), dag_fix_image_reuse(), freia_allocate_new_images_if_needed(), freia_dag_optimize(), freia_insert_added_stats(), gen_free_list(), gen_length(), hash_pointer, hash_table_free(), hash_table_make(), init, module, NIL, pips_assert, and pips_debug.

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_aipo_compiler()

bool freia_aipo_compiler

(

const

string

)

Parameters

string

odule

Definition at line 134 of file hardware_accelerator.c.

{
  return freia_compiler(module, "aipo");
}

References freia_compiler(), and module.

Here is the call 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

)

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_dag()

dag freia_build_dag	(	string	module,
		list	ls,
		int	number,
		const hash_table	occurrences,
		const set	output_images,
		const list	ld,
		bool	inloop
	)

build a full dag from list of statements ls.

Parameters

module
list	of statements in sequence
number	dag identifier in function
occurrences	entity -> set of statements where they appear
output_images	set of images that are output
ld	list of other dags... (???)
inloop	whether we might be in a loop

Parameters

module	odule
ls	s
number	umber
occurrences	ccurrences
output_images	utput_images
ld	d
inloop	nloop

Definition at line 2476 of file dag-utils.c.

{
  // build full dag
  dag fulld = make_dag(NIL, NIL, NIL);
 
  FOREACH(statement, s, ls)
    dag_append_freia_call(fulld, s);
 
  dag_compute_outputs(fulld, occurrences, output_images, ld, inloop);
 
  ifdebug(3) dag_dump(stderr, "fulld", fulld);
 
  // dump resulting dag
  dag_dot_dump_prefix(module, "dag_", number, fulld, NIL, NIL);
 
  return fulld;
}

References dag_append_freia_call(), dag_compute_outputs(), dag_dot_dump_prefix(), dag_dump(), FOREACH, ifdebug, make_dag(), module, and NIL.

Referenced by freia_compile().

Here is the call graph for this function:

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_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_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,
		list	lparams
	)

Parameters

string	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_dag_optimize()

void freia_dag_optimize	(	dag	d,
		hash_table	exchanges,
		list *	lbefore,
		list *	lafter
	)

remove dead image operations.

remove AIPO copies detected as useless. remove identical operations. return list of statements to be managed outside (external copies)... ??? maybe there should be a transitive closure...

Parameters

exchanges	xchanges
lbefore	before
lafter	after

Definition at line 1416 of file dag-utils.c.

{
  set remove = set_make(set_pointer);
  size_t dag_output_count = gen_length(dag_outputs(d));
 
  ifdebug(6) {
    pips_debug(6, "considering dag:\n");
    dag_dump(stderr, "input", d);
  }
 
  if (get_bool_property("FREIA_NORMALIZE_OPERATIONS"))
  {
    dag_normalize(d);
 
    ifdebug(8) {
      pips_debug(4, "after FREIA_NORMALIZE_OPERATIONS:\n");
      dag_dump(stderr, "normalized", d);
    }
  }
 
  // algebraic simplifications
  // currently constant images are detected and propagated and constant pixels
  if (get_bool_property("FREIA_SIMPLIFY_OPERATIONS"))
  {
    dag_simplify(d);
 
    ifdebug(8) {
      pips_debug(4, "after FREIA_SIMPLIFY_OPERATIONS (1):\n");
      dag_dump(stderr, "simplified_1", d);
      // dag_dot_dump_prefix("main", "simplified", 0, d);
    }
  }
 
  // look for identical image operations (same inputs, same params)
  // (that produce image, we do not care about measures for SPOC,
  // but we should for terapix!)
  // the second one is replaced by a copy.
  // also handle commutations.
  if (get_bool_property("FREIA_REMOVE_DUPLICATE_OPERATIONS"))
  {
    pips_debug(6, "removing duplicate operations\n");
 
    // all vertices in dependence order
    list vertices = gen_nreverse(gen_copy_seq(dag_vertices(d)));
 
    // for all already processed vertices, the list of their predecessors
    hash_table previous = hash_table_make(hash_pointer, 10);
 
    // subset of vertices to be investigated
    set candidates = set_make(set_pointer);
 
    // subset of vertices already encountered which do not have predecessors
    set sources = set_make(set_pointer);
 
    // already processed vertices
    set processed = set_make(set_pointer);
 
    // potential n^2 loop, optimized by comparing only to the already processed
    // successors of the vertex predecessors . See "candidates" computation.
    FOREACH(dagvtx, vr, vertices)
    {
      int op = (int) vtxcontent_optype(dagvtx_content(vr));
      pips_debug(7, "at vertex %"_intFMT" (op=%d)\n", dagvtx_number(vr), op);
 
      // skip no-operations
      if (op<spoc_type_poc || op>spoc_type_mes) continue;
 
      // skip already removed ops
      if (set_belong_p(remove, vr)) continue;
 
      // pips_debug(8, "investigating...\n");
      list preds = dag_vertex_preds(d, vr);
 
      // build only "interesting" vertices, which shared inputs
      set_clear(candidates);
 
      // successors of predecessors
      FOREACH(dagvtx, p, preds)
        set_append_list(candidates, dagvtx_succs(p));
 
      // keep only already processed vertices
      set_intersection(candidates, candidates, processed);
 
      // possibly add those without predecessors (is that only set_const?)
      if (!preds) set_union(candidates, candidates, sources);
 
      // whether the vertex was changed
      bool switched = false;
 
      // I do not need to sort them, they are all different, only one can match
      SET_FOREACH(dagvtx, p, candidates)
      {
        pips_debug(8, "comparing %"_intFMT" and %"_intFMT"\n",
                   dagvtx_number(vr), dagvtx_number(p));
 
        list lp = hash_get(previous, p);
 
        // ??? maybe I should not remove all duplicates, because
        // recomputing them may be cheaper?
        if (dagvtx_is_measurement_p(vr) || dagvtx_is_measurement_p(p))
        {
          // special handling for measures, esp for terapix
          if (gen_list_equals_p(preds, lp))
          {
            if (same_operation_p(vr, p))
            {
              // min(A, px), min(A, py) => min(A, px) && *py = *px
              if (switch_vertex_to_assign(vr, p))
                set_add_element(remove, remove, vr);
              // only one can match!
              switched = true;
              break;
            }
            else
            {
              int n = compatible_reduction_operation(p, vr);
              if (n==2)
              {
                // exchange role of vr & p
                set_del_element(processed, processed, p);
                set_add_element(processed, processed, vr);
                hash_del(previous, p);
                hash_put(previous, vr, lp);
                dagvtx t = p; p = vr; vr = t;
                // also in the list of statements to fix dependencies!
                if (exchanges) hash_put(exchanges, p, vr);
              }
              if (n==1 || n==2)
              {
                // we keep p which is a !, and vr is a simple reduction
                if (switch_vertex_to_assign(vr, p))
                  set_add_element(remove, remove, vr);
 
                // done
                switched = true;
                break;
              }
            }
          }
        }
        else if (same_operation_p(vr, p) &&
                 gen_list_equals_p(preds, lp) &&
                 same_constant_parameters(vr, p))
        {
          switch_vertex_to_a_copy(vr, p, preds);
          // only one can match!
          switched = true;
          break;
        }
        else if (commutative_operation_p(vr, p) &&
                 list_commuted_p(preds, (list) lp))
        {
          switch_vertex_to_a_copy(vr, p, preds);
          // only one can match!
          switched = true;
          break;
        }
      }
 
      if (switched)
        gen_free_list(preds);
      else
      {
        // update map & sets
        hash_put(previous, vr, preds);
        set_add_element(processed, processed, vr);
        if (!preds) set_add_element(sources, sources, vr);
      }
    }
 
    // cleanup
    HASH_MAP(k, v, if (v) gen_free_list(v), previous);
    hash_table_free(previous), previous = NULL;
    gen_free_list(vertices), vertices = NULL;
    set_free(candidates);
    set_free(sources);
    set_free(processed);
 
    ifdebug(8) {
      pips_debug(4, "after FREIA_REMOVE_DUPLICATE_OPERATIONS:\n");
      dag_dump(stderr, "remove duplicate", d);
      // dag_dot_dump_prefix("main", "remove_duplicates", 0, d);
    }
  }
 
  // algebraic simplifications *AGAIN*
  // some duplicate operation removal may have enabled more simplifications
  // for instance -(a,b) & a=~b => -(a,a) => cst(0)
  // we may have a convergence loop on both duplicate/simplify
  if (get_bool_property("FREIA_SIMPLIFY_OPERATIONS"))
  {
    dag_simplify(d);
 
    ifdebug(8) {
      pips_debug(4, "after FREIA_SIMPLIFY_OPERATIONS (2):\n");
      dag_dump(stderr, "simplified_2", d);
      // dag_dot_dump_prefix("main", "simplified", 0, d);
    }
  }
 
  // remove dead image operations
  // ??? hmmm... measures are kept because of the implicit scalar dependency?
  if (get_bool_property("FREIA_REMOVE_DEAD_OPERATIONS"))
  {
    pips_debug(6, "removing dead code\n");
    list vertices = gen_copy_seq(dag_vertices(d));
    FOREACH(dagvtx, v, vertices)
    {
      // skip non-image operations
      if (!vtxcontent_inputs(dagvtx_content(v)) &&
          (vtxcontent_out(dagvtx_content(v))==entity_undefined ||
           vtxcontent_out(dagvtx_content(v))==NULL))
        continue;
 
      if (// no successors or they are all removed
          (!dagvtx_succs(v) || list_in_set_p(dagvtx_succs(v), remove)) &&
          // but we keep output nodes...
          !gen_in_list_p(v, dag_outputs(d)) &&
          // and measures...
          !dagvtx_is_measurement_p(v))
      {
        pips_debug(7, "vertex %"_intFMT" is dead\n", dagvtx_number(v));
        set_add_element(remove, remove, v);
      }
      else
        pips_debug(8, "vertex %"_intFMT" is alive\n", dagvtx_number(v));
    }
    gen_free_list(vertices), vertices = NULL;
 
    ifdebug(8) {
      pips_debug(4, "after FREIA_REMOVE_DEAD_OPERATIONS:\n");
      dag_dump(stderr, "remove dead", d);
      // dag_dot_dump_prefix("main", "remove_dead", 0, d);
    }
  }
 
  if (get_bool_property("FREIA_REMOVE_USELESS_COPIES"))
  {
    set forwards = set_make(set_pointer);
    bool changed = true;
 
    // I -copy-> X -> ... where I is an input is moved forward
    // beware that image identifiers should not be reused, otherwise it may
    // merge two arcs... (freia_82 & freia_83)
 
    // we iterate the hard way, it could be little more subtle
    // this is necessary, see copy_02
    while (changed)
    {
      changed = false;
 
      // first propagate input images through copies
      FOREACH(dagvtx, v, dag_inputs(d))
      {
        list append = NIL;
        entity in = vtxcontent_out(dagvtx_content(v));
 
        FOREACH(dagvtx, s, dagvtx_succs(v))
        {
          entity copy = vtxcontent_out(dagvtx_content(s));
          if (dagvtx_is_copy_p(s))
          {
            // forward propagation in dag & statements
            FOREACH(dagvtx, s2, dagvtx_succs(s))
            {
              substitute_image_in_statement(s2, copy, in, true);
              gen_replace_in_list(vtxcontent_inputs(dagvtx_content(s2)),
                                copy, in);
            }
            // update succs
            append = gen_nconc(dagvtx_succs(s), append);
            dagvtx_succs(s) = NIL;
 
            set_add_element(forwards, forwards, s);
          }
        }
        if (append)
        {
          FOREACH(dagvtx, a, append)
          {
            if (!gen_in_list_p(a, dagvtx_succs(v)))
            {
              dagvtx_succs(v) = CONS(dagvtx, a, dagvtx_succs(v));
              changed = true;
            }
          }
        }
      }
    }
 
    // op -> X -copy-> A where A is an output is moved backwards
    FOREACH(dagvtx, v, dag_vertices(d))
    {
      // skip special input nodes
      if (dagvtx_number(v)==0) continue;
 
      // skip already removed ops
      if (set_belong_p(remove, v)) continue;
 
      // skip forward propagated inputs
      if (set_belong_p(forwards, v)) continue;
 
      if (dagvtx_is_copy_p(v))
      {
        list preds = dag_vertex_preds(d, v);
        vtxcontent c = dagvtx_content(v);
        entity res = vtxcontent_out(c);
        pips_assert("one output and one input to copy",
                    res!=entity_undefined &&
                    gen_length(preds)==1 &&
                    gen_length(vtxcontent_inputs(c))==1);
 
        // first check for A->copy->A really useless copies, which are skipped
        entity inimg = ENTITY(CAR(vtxcontent_inputs(c)));
        if (inimg==res)
        {
          set_add_element(remove, remove, v);
          dagvtx pred = DAGVTX(CAR(preds));
          // update predecessor's successors
          gen_remove(&dagvtx_succs(pred), v);
          dagvtx_succs(pred) = gen_nconc(dagvtx_succs(pred), dagvtx_succs(v));
          // fix global output if necessary
          if (gen_in_list_p(v, dag_outputs(d)))
            gen_replace_in_list(dag_outputs(d), v, pred);
        }
        // check for internal-t -one-copy-and-others-> A (output)
        // could be improved by dealing with the first copy only?
        else if (gen_in_list_p(v, dag_outputs(d)))
        {
          pips_assert("one predecessor to used copy", gen_length(preds)==1);
          dagvtx pred = DAGVTX(CAR(preds));
 
          if (number_of_copies(dagvtx_succs(pred))==1 &&
              !gen_in_list_p(pred, dag_outputs(d)) &&
              dagvtx_number(pred)!=0)
          {
            // BACKWARD COPY PROPAGATION
            // that is we want to produce the result directly
 
            vtxcontent pc = dagvtx_content(pred);
            entity old = vtxcontent_out(pc);
 
            // fix statement, needed for AIPO target
            substitute_image_in_statement(pred, old, res, false);
 
            // fix vertex
            vtxcontent_out(pc) = res;
            gen_remove(& dagvtx_succs(pred), v);
            bool done = gen_replace_in_list(dag_outputs(d), v, pred);
            pips_assert("output node was replaced", done);
            set_add_element(remove, remove, v);
 
            // BACK-FORWARD COPY PROPAGATION
            FOREACH(dagvtx, s, dagvtx_succs(pred))
            {
              substitute_image_in_statement(s, old, res, true);
              gen_replace_in_list(vtxcontent_inputs(dagvtx_content(s)),
                                  old, res);
            }
          }
          gen_free_list(preds);
        }
      }
    }
 
    // only one pass is needed because we're going backwards?
    // op-> X -copy-> Y images copies are replaced by op-> X & Y
    FOREACH(dagvtx, v, dag_vertices(d))
    {
      // skip special input nodes
      if (dagvtx_number(v)==0) continue;
 
      // skip already removed ops
      if (set_belong_p(remove, v)) continue;
 
      if (dagvtx_is_copy_p(v))
      {
        vtxcontent c = dagvtx_content(v);
        entity target = vtxcontent_out(c);
        pips_assert("one output and one input to copy",
              target!=entity_undefined && gen_length(vtxcontent_inputs(c))==1);
 
        // FORWARD COPY PROPAGATION
        // replace by its source everywhere it is used
        entity source = ENTITY(CAR(vtxcontent_inputs(c)));
 
        // remove!
        unlink_copy_vertex(d, source, v);
 
        // whether to actually remove v
        if (!gen_in_list_p(v, dag_outputs(d)))
          set_add_element(remove, remove, v);
      }
    }
 
    set_free(forwards);
 
    ifdebug(8) {
      pips_debug(4, "after FREIA_REMOVE_USELESS_COPIES:\n");
      dag_dump(stderr, "remove useless copies", d);
      // dag_dot_dump_prefix("main", "useless_copies", 0, d);
    }
  }
 
  if (get_bool_property("FREIA_MOVE_DIRECT_COPIES"))
  {
    // A-copy->B where A is an input is removed from the dag and managed outside
    // idem A-copy->B where A is an output
 
    // if A-copy->X and A-copy->Y where A is not an input, the second copy
    // is replaced by an external X-copy->Y
 
    // ??? BUG: it should be moved after the computation
 
    // what copies are kept in the dag
    hash_table intra_pipe_copies = hash_table_make(hash_pointer, 10);
 
    FOREACH(dagvtx, w, dag_vertices(d))
    {
      // skip already to-remove nodes
      if (set_belong_p(remove, w))
        continue;
 
      if (dagvtx_is_copy_p(w))
      {
        vtxcontent c = dagvtx_content(w);
        entity target = vtxcontent_out(c);
        pips_assert("one output and one input to copy",
              target!=entity_undefined && gen_length(vtxcontent_inputs(c))==1);
 
        entity source = ENTITY(CAR(vtxcontent_inputs(c)));
        dagvtx prod = dagvtx_get_producer(d, w, source, 0);
 
        if (source==target)
        {
          // A->copy->A??? this should not happen?
          set_add_element(remove, remove, w);
        }
        else if (dagvtx_number(prod)==0)
        {
          // producer is an input
          // fprintf(stderr, "COPY 1 removing %"_intFMT"\n", dagvtx_number(w));
          unlink_copy_vertex(d, source, w);
          set_add_element(remove, remove, w);
          *lbefore =
            CONS(statement, freia_copy_image(source, target), *lbefore);
        }
        else if (gen_in_list_p(prod, dag_outputs(d)))
        {
          // the producer is an output, which can be copied outside...
          // well, it may happen that the copy could be performed by the
          // accelerator for free, eg for SPoC one output link would happen
          // to be available... so we may really add an operation when
          // extracting it. However, this should not be an accelerator call?
          unlink_copy_vertex(d, source, w);
          set_add_element(remove, remove, w);
          *lafter = CONS(statement, freia_copy_image(source, target), *lafter);
        }
        else // source not an input, but the result of an internal computation
        {
          if (all_vertices_are_copies_or_measures_p(dagvtx_succs(prod)))
          {
            // ??? hmmm... there is an implicit assumption here that the
            // source of the copy will be an output...
            unlink_copy_vertex(d, source, w);
            set_add_element(remove, remove, w);
            *lafter =
              CONS(statement, freia_copy_image(source, target), *lafter);
          }
          else if (hash_defined_p(intra_pipe_copies, source))
          {
            // the source is already copied
            unlink_copy_vertex(d, source, w);
            set_add_element(remove, remove, w);
            *lafter = CONS(statement,
                 freia_copy_image((entity) hash_get(intra_pipe_copies, source),
                                  target), *lafter);
          }
          else // keep first copy
            hash_put(intra_pipe_copies, source, target);
        }
      }
    }
    hash_table_free(intra_pipe_copies);
 
    ifdebug(8) {
      pips_debug(4, "after FREIA_MOVE_DIRECT_COPIES:\n");
      dag_dump(stderr, "move direct copies", d);
      // dag_dot_dump_prefix("main", "direct_copies", 0, d);
    }
  }
 
  // cleanup dag (argh, beware that the order is not deterministic...)
  SET_FOREACH(dagvtx, r, remove)
  {
    pips_debug(7, "removing vertex %" _intFMT "\n", dagvtx_number(r));
 
    vtxcontent c = dagvtx_content(r);
    if (pstatement_statement_p(vtxcontent_source(c)))
      hwac_kill_statement(pstatement_statement(vtxcontent_source(c)));
    dag_remove_vertex(d, r);
 
    ifdebug(8)
      gen_context_recurse(d, r, dagvtx_domain, gen_true2, check_removed);
 
    free_dagvtx(r);
  }
 
  set_free(remove);
 
  // further check for unused input nodes
  // this seems needed because some non determinism in the above cleanup.
  list vertices = gen_copy_seq(dag_vertices(d));
  FOREACH(dagvtx, v, vertices)
  {
    if (dagvtx_number(v)==0 && !dagvtx_succs(v))
    {
      dag_remove_vertex(d, v);
      free_dagvtx(v);
    }
  }
  gen_free_list(vertices);
 
  // show result
  ifdebug(6) {
    pips_debug(4, "resulting dag:\n");
    dag_dump(stderr, "cleaned", d);
    // dag_dot_dump_prefix("main", "cleaned", 0, d);
  }
 
  // former output images are either still computed or copies of computed
  size_t recount = gen_length(dag_outputs(d)) +
    gen_length(*lbefore) + gen_length(*lafter);
  pips_assert("right output count after dag optimizations",
              dag_output_count==recount);
}

References _intFMT, all_vertices_are_copies_or_measures_p(), append, CAR, check_removed(), commutative_operation_p(), compatible_reduction_operation(), CONS, dag_dump(), dag_inputs, dag_normalize(), dag_outputs, dag_remove_vertex(), dag_simplify(), dag_vertex_preds(), dag_vertices, DAGVTX, dagvtx_content, dagvtx_domain, dagvtx_get_producer(), dagvtx_is_copy_p(), dagvtx_is_measurement_p(), dagvtx_number(), dagvtx_succs, ENTITY, entity_undefined, FOREACH, free_dagvtx(), freia_copy_image(), gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_in_list_p(), gen_length(), gen_list_equals_p(), gen_nconc(), gen_nreverse(), gen_remove(), gen_replace_in_list(), gen_true2(), get_bool_property(), hash_defined_p(), hash_del(), hash_get(), HASH_MAP, hash_pointer, hash_put(), hash_table_free(), hash_table_make(), hwac_kill_statement(), ifdebug, int, list_commuted_p(), list_in_set_p(), NIL, number_of_copies(), pips_assert, pips_debug, pstatement_statement, pstatement_statement_p, same_constant_parameters(), same_operation_p(), set_add_element(), set_append_list(), set_belong_p(), set_clear(), set_del_element(), SET_FOREACH, set_free(), set_intersection(), set_make(), set_pointer, set_union(), spoc_type_mes, substitute_image_in_statement(), switch_vertex_to_a_copy(), switch_vertex_to_assign(), unlink_copy_vertex(), vtxcontent_inputs, vtxcontent_optype, vtxcontent_out, and vtxcontent_source.

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

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,
		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

)

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_hack_fix_global_ins_outs()

void freia_hack_fix_global_ins_outs	(	dag	dfull,
		dag	d
	)

catch some cases of missing outs between splits...

for "freia_scalar_03"... I'm not that sure about the algorithm. This should rely be based on the CHAINS/DG, but the status still seems hopeless, as too many arcs currently kept (FC 08/08/2011)

Parameters

dfull

full dag

Parameters

dfull

full

Definition at line 2166 of file dag-utils.c.

{
  // cleanup inputs?
  // cleanup outputs
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    // skip input nodes
    if (dagvtx_number(v)==0)
      continue;
 
    dagvtx twin = find_twin_vertex(dfull, v);
    if (// the vertex was an output node in the full dag
        gen_in_list_p(twin, dag_outputs(dfull)) ||
        // OR there were more successors in the full dag
        gen_length(dagvtx_succs(v))!=gen_length(dagvtx_succs(twin)))
    {
      pips_debug(4, "adding %" _intFMT " as output\n", dagvtx_number(v));
      dag_outputs(d) = gen_once(v, dag_outputs(d));
    }
  }
}

References _intFMT, dag_outputs, dag_vertices, dagvtx_number(), dagvtx_succs, find_twin_vertex(), FOREACH, gen_in_list_p(), gen_length(), gen_once(), and pips_debug.

Referenced by compile_this_list(), dag_split_connected_components(), dag_split_on_scalars(), and opencl_merge_and_compile().

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

)

rather approximative?

Parameters

entity

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_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_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_memory_management_statement()

statement freia_memory_management_statement	(	entity	image,
		const hash_table	occs,
		bool	alloc
	)

Returns

statement where image is allocated/deallocated maybe I should build another hash_table for this purpose?

Parameters

image	mage
occs	ccs
alloc	lloc

Definition at line 2586 of file dag-utils.c.

{
  pips_debug(8, "look for %s statement for %s\n",
             alloc? "allocation": "deallocation", entity_name(image));
 
  if (hash_defined_p(occs, image))
  {
    SET_FOREACH(statement, s, (set) hash_get(occs, image))
    {
      // it may already have been switched to a sequence by a prior insert...
      // ??? it is unclear why I encounter nested sequences
      while (statement_sequence_p(s))
        s = STATEMENT(CAR(sequence_statements(statement_sequence(s))));
 
      // fprintf(stderr, "statement %"_intFMT"?\n", statement_number(s));
      if (alloc && is_freia_alloc(s))
      {
        call c = statement_call(s);
        pips_assert("must be an assignment", ENTITY_ASSIGN_P(call_function(c)));
        entity var;
        gen_context_recurse(EXPRESSION(CAR(call_arguments(c))), &var,
                            reference_domain, image_ref_flt, gen_null2);
        if (var==image) return s;
      }
      else if (!alloc && is_freia_dealloc(s))
      {
        call c = statement_call(s);
        entity var;
        gen_context_recurse(EXPRESSION(CAR(call_arguments(c))), &var,
                            reference_domain, image_ref_flt, gen_null2);
        if (var==image) return s;
      }
    }
  }
  return NULL;
}

References alloc(), call_arguments, call_function, CAR, ENTITY_ASSIGN_P, entity_name, EXPRESSION, gen_context_recurse, gen_null2(), hash_defined_p(), hash_get(), image_ref_flt(), is_freia_alloc(), is_freia_dealloc(), pips_assert, pips_debug, reference_domain, sequence_statements, SET_FOREACH, STATEMENT, statement_call(), statement_sequence(), and statement_sequence_p().

Referenced by freia_allocate_new_images_if_needed(), and new_local_image_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_migrate_statements()

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

Parameters

sq	q
set	tats
set	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_mppa_compile_calls()

list freia_mppa_compile_calls	(	string	,
		dag	,
		sequence	,
		list	,
		const	hash_table,
		hash_table	,
		const	set,
		FILE *	,
		set	,
		int
	)

freia_mppa.c

Parameters

hash_table	ccs
set	utput_images

freia_mppa_compiler()

bool freia_mppa_compiler

(

const

string

)

Parameters

string

odule

Definition at line 149 of file hardware_accelerator.c.

                                              {
  return freia_compiler(module, "mppa");
}

References freia_compiler(), and module.

Here is the call 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_opencl_compile_calls()

list freia_opencl_compile_calls	(	string	module,
		dag	fulld,
		sequence	sq,
		list	ls,
		const	hash_table,
		hash_table	exchanges,
		const	set,
		FILE *	helper_file,
		set	helpers,
		int	number,
		hash_table	signatures
	)

freia_opencl.c

Parameters

module	odule
fulld	ulld
sq	q
ls	s
hash_table	ccs
exchanges	xchanges
set	utput_images
helper_file	elper_file
helpers	elpers
number	umber
signatures	ignatures

Definition at line 1371 of file freia_opencl.c.

{
  pips_debug(3, "considering %d statements\n", (int) gen_length(ls));
  pips_assert("some statements", ls);
 
  int n_op_init, n_op_init_copies;
  freia_aipo_count(fulld, &n_op_init, &n_op_init_copies);
 
  // must have distinct images in the graph for optimizations
  hash_table init = hash_table_make(hash_pointer, 0);
  list new_images = dag_fix_image_reuse(fulld, init, occs);
 
  list added_before = NIL, added_after = NIL;
  freia_dag_optimize(fulld, exchanges, &added_before, &added_after);
 
  int n_op_opt, n_op_opt_copies;
  freia_aipo_count(fulld, &n_op_opt, &n_op_opt_copies);
 
  fprintf(helper_file,
          "\n"
          "// dag %d: %d ops and %d copies, "
          "optimized to %d ops and %d+%d+%d copies\n",
          number, n_op_init, n_op_init_copies,
          n_op_opt, n_op_opt_copies,
          (int) gen_length(added_before), (int) gen_length(added_after));
 
  // opencl file
  string opencl_file = get_opencl_file_name(module);
  FILE * opencl;
  if (file_readable_p(opencl_file))
    opencl = safe_fopen(opencl_file, "a");
  else
  {
    opencl = safe_fopen(opencl_file, "w");
    fprintf(opencl,
            FREIA_OPENCL_CL_INCLUDES "\n"
            "// generated OpenCL kernels for function %s\n", module);
  }
  fprintf(opencl, "\n" "// opencl for dag %d\n", number);
 
  // dump final optimised dag
  dag_dot_dump_prefix(module, "dag_cleaned_", number, fulld,
                      added_before, added_after);
 
  string fname_fulldag = strdup(cat(module, "_opencl", HELPER, i2a(number)));
 
  list ld =
    dag_split_on_scalars(fulld, dagvtx_other_stuff_p, choose_opencl_vertex,
                         (gen_cmp_func_t) dagvtx_opencl_priority,
                         NULL, output_images);
 
  pips_debug(3, "dag initial split in %d dags\n", (int) gen_length(ld));
 
  int n_split = 0;
 
  if (get_bool_property(opencl_merge_prop))
  {
    set stats = set_make(set_pointer), dones = set_make(set_pointer);
    FOREACH(dag, d, ld)
    {
      if (dag_no_image_operation(d))
        continue;
 
      // fix statements connexity
      dag_statements(stats, d);
      freia_migrate_statements(sq, stats, dones);
      set_union(dones, dones, stats);
 
      opencl_merge_and_compile(module, sq, ls, d, fname_fulldag, n_split,
                               fulld, output_images, helper_file, opencl,
                               helpers, signatures);
 
      n_split++;
    }
    set_free(stats);
    set_free(dones);
  }
  // else, do nothing, this is basically like AIPO
 
  // now may put actual allocations, which messes up statement numbers
  list reals =
    freia_allocate_new_images_if_needed(ls, new_images, occs, init, signatures);
 
  // hmmm... is this too late?
  freia_insert_added_stats(ls, added_before, true);
  added_before = NIL;
  freia_insert_added_stats(ls, added_after, false);
  added_after = NIL;
 
  // cleanup
  gen_free_list(new_images);
  hash_table_free(init);
  safe_fclose(opencl, opencl_file);
  free(opencl_file);
 
  return reals;
}

References cat, choose_opencl_vertex(), dag_dot_dump_prefix(), dag_fix_image_reuse(), dag_no_image_operation(), dag_split_on_scalars(), dag_statements(), dagvtx_opencl_priority(), dagvtx_other_stuff_p(), file_readable_p(), FOREACH, fprintf(), free(), freia_aipo_count(), freia_allocate_new_images_if_needed(), freia_dag_optimize(), freia_insert_added_stats(), freia_migrate_statements(), FREIA_OPENCL_CL_INCLUDES, gen_free_list(), gen_length(), get_bool_property(), get_opencl_file_name(), hash_pointer, hash_table_free(), hash_table_make(), HELPER, i2a(), init, module, NIL, opencl_merge_and_compile(), opencl_merge_prop, pips_assert, pips_debug, safe_fclose(), safe_fopen(), set_free(), set_make(), set_pointer, set_union(), and strdup().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_opencl_compiler()

bool freia_opencl_compiler

(

const

string

)

Parameters

string

odule

Definition at line 139 of file hardware_accelerator.c.

{
  return freia_compiler(module, "opencl");
}

References freia_compiler(), and module.

Here is the call graph for this function:

freia_remove_scalar_ww_deps()

bool freia_remove_scalar_ww_deps

(

const

string

)

Parameters

string

odule

Definition at line 430 of file freia_transformations.c.

{
  debug_on("PIPS_HWAC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
 
  // else do the stuff
  statement mod_stat =
    (statement) db_get_memory_resource(DBR_CODE, module, true);
  set_current_module_statement(mod_stat);
  set_current_module_entity(module_name_to_entity(module));
 
  // do the job
  bool changed = false;
  gen_context_recurse(mod_stat, &changed,
                      sequence_domain, gen_true2, sww_seq_rwt);
 
  // update database if changed
  if (changed)
    // stmt_renumber(mod_stat); module_reorder(mod_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, mod_stat);
 
  reset_current_module_statement();
  reset_current_module_entity();
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_context_recurse, gen_true2(), mod_stat, module, module_name_to_entity(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), sequence_domain, set_current_module_entity(), set_current_module_statement(), and sww_seq_rwt().

Here is the call graph for this function:

freia_scalar_rw_dep()

bool freia_scalar_rw_dep	(	const	statement,
		const	statement,
		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_shuffle_move_forward()

void freia_shuffle_move_forward

(

statement

s

)

Definition at line 876 of file freia_transformations.c.

{
  shuffle_context ctx = { 0, 0, NIL, NULL };
  // forward substitude simple image assignments
  gen_context_recurse(s, &ctx, sequence_domain, gen_true2, seq_rwt);
  // remove image assignments that are not used
  // TODO ??? initializations...
  // count image read references
  hash_table reads = hash_table_make(hash_pointer, 100); // entity -> _int
  gen_context_multi_recurse(s, reads,
                            call_domain, call_count_flt, gen_null2,
                            reference_domain, gen_true2, ref_count_rwt,
                            NULL);
  // cleanup assignments of unused images
  FOREACH(statement, sa, ctx.assigns)
  {
    // be safe
    pips_assert(statement_call_p(sa), "statement is a call");
    call c = statement_call(sa);
    pips_assert(ENTITY_ASSIGN_P(call_function(c)), "call is assign");
    list args = call_arguments(c);
    pips_assert(gen_length(args) == 2, "2 args to assign");
    expression e1 = EXPRESSION(CAR(args));
    pips_assert(expression_reference_p(e1), "expr is reference");
    reference r = expression_reference(e1);
    entity img = reference_variable(r);
    pips_assert(reference_indices(r) == NIL, "no array reference");
    pips_assert(freia_image_variable_p(img), "reference an image");
 
    // cleanup unused images
    if (!hash_defined_p(reads, img))
    {
      // remove assignment of unused image pointer
      free_instruction(statement_instruction(sa));
      statement_instruction(sa) = make_continue_instruction();
      // coldly cleanup corresponding effects... (free effects not needed?)
      delete_cumulated_rw_effects(sa);
      store_cumulated_rw_effects_list(sa, NIL);
      // ??? what about proper effects?
      // stats
      ctx.removed ++;
    }
  }
  hash_table_free(reads), reads = NULL;
 
  // be verbose because I'm not sure of the pass
  if (ctx.changed != 0 || ctx.removed != 0)
    pips_user_warning("%d subsitution(s) and %d assignment(s) removed",
                      ctx.changed, ctx.removed);
 
  gen_free_list(ctx.assigns), ctx.assigns = NIL;
}

References shuffle_context::assigns, call_arguments, call_count_flt(), call_domain, call_function, CAR, shuffle_context::changed, delete_cumulated_rw_effects(), ENTITY_ASSIGN_P, EXPRESSION, expression_reference(), expression_reference_p(), FOREACH, free_instruction(), freia_image_variable_p(), gen_context_multi_recurse(), gen_context_recurse, gen_free_list(), gen_length(), gen_null2(), gen_true2(), hash_defined_p(), hash_pointer, hash_table_free(), hash_table_make(), make_continue_instruction(), NIL, pips_assert, pips_user_warning, ref_count_rwt(), reference_domain, reference_indices, reference_variable, shuffle_context::removed, seq_rwt(), sequence_domain, statement_call(), statement_call_p(), statement_instruction, and store_cumulated_rw_effects_list().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_sigmac_compile_calls()

list freia_sigmac_compile_calls	(	string	,
		dag	,
		sequence	,
		list	,
		const	hash_table,
		hash_table	,
		const	set,
		FILE *	,
		set	,
		int	,
		int
	)

freia_sigmac.c

Parameters

hash_table	ccs
set	utput_images

Referenced by freia_compile(), and sc_delimiter().

Here is the caller graph for this function:

freia_sigmac_compiler()

bool freia_sigmac_compiler

(

const

string

)

Parameters

string

odule

Definition at line 144 of file hardware_accelerator.c.

{
  return freia_compiler(module, "sigmac");
}

References freia_compiler(), and module.

Here is the call graph for this function:

freia_some_effects_on_images()

bool freia_some_effects_on_images

(

statement

s

)

freia.c

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_spoc_compile_calls()

list freia_spoc_compile_calls	(	string	module,
		dag	fulld,
		sequence	sq,
		list	ls,
		const hash_table	occs,
		hash_table	exchanges,
		const set	output_images,
		FILE *	helper_file,
		set	helpers,
		int	number
	)

freia_spoc.c

freia_spoc.c

Parameters

module
ls	list of statements for the dag (in reverse order)
helper	output file
helpers	created functions
number	current helper dag count

Returns

list of intermediate images to allocate

of expression

Parameters

module	odule
fulld	ulld
sq	q
ls	of statements
occs	ccs
exchanges	xchanges
output_images	utput_images
helper_file	elper_file
helpers	elpers
number	umber

Definition at line 2246 of file freia_spoc.c.

{
  // build DAG for ls
  pips_debug(3, "considering %d statements\n", (int) gen_length(ls));
  pips_assert("some statements", ls);
 
  int n_op_init, n_op_init_copies;
  freia_aipo_count(fulld, &n_op_init, &n_op_init_copies);
 
  // must have distinct images...
  hash_table init = hash_table_make(hash_pointer, 0);
  list new_images = dag_fix_image_reuse(fulld, init, occs);
 
  list added_before = NIL, added_after = NIL;
  freia_dag_optimize(fulld, exchanges, &added_before, &added_after);
 
  // remove copies and duplicates if possible...
  // ??? maybe there should be an underlying transitive closure? not sure.
  int n_op_opt, n_op_opt_copies;
  freia_aipo_count(fulld, &n_op_opt, &n_op_opt_copies);
 
  fprintf(helper_file,
          "\n"
          "// dag %d: %d ops and %d copies, "
          "optimized to %d ops and %d+%d+%d copies\n",
          number, n_op_init, n_op_init_copies,
          n_op_opt, n_op_opt_copies,
          (int) gen_length(added_before), (int) gen_length(added_after));
 
  // dump final dag
  dag_dot_dump_prefix(module, "dag_cleaned_", number, fulld,
                      added_before, added_after);
 
  string fname_fulldag = strdup(cat(module, "_spoc", HELPER, i2a(number)));
 
  // split dag in one-pipe dags.
  list ld = split_dag(fulld, output_images);
 
  // nothing to do!
  // it would have been interesting not to create thehelper file in this case.
  // if (ld==NIL) return;
 
  FOREACH(dag, dfix, ld)
    freia_hack_fix_global_ins_outs(fulld, dfix);
 
  // globally remaining statements
  set global_remainings = set_make(set_pointer);
  set_assign_list(global_remainings, ls);
 
  string_buffer code = string_buffer_make(true);
 
  int n_spoc_calls = 0;
  int n_pipes = 0;
  int stnb = -1;
 
  set stats = set_make(set_pointer), dones = set_make(set_pointer);
 
  FOREACH(dag, d, ld)
  {
    // skip non implemented stuff
    if (dag_spoc_not_implemented(d))
      continue;
 
    // fix connectivity
    dag_statements(stats, d);
    freia_migrate_statements(sq, stats, dones);
    set_union(dones, dones, stats);
 
    set remainings = set_make(set_pointer);
    set_append_vertex_statements(remainings, dag_vertices(d));
    // remove special inputs nodes
    // FOREACH(dagvtx, inp, dag_inputs(d))
    // set_del_element(remainings, remainings, inp);
 
    // generate a new helper function for dag d
    string fname_dag = strdup(cat(fname_fulldag, "_", i2a(n_pipes++)));
 
    ifdebug(4) dag_dump(stderr, "d", d);
    dag_dot_dump(module, fname_dag, d, NIL, NIL);
 
    // one logical pipeline may be split because of overflow
    // the dag is updated to reflect that as a code generation side effect
    int split = 0;
    while (dag_vertices(d))
    {
      // fix internal ins/outs, that are tempered with by split & overflows
      freia_hack_fix_global_ins_outs(fulld, d);
 
      ifdebug(6) {
        pips_debug(4, "dag for split %d\n", split);
        dag_dump(stderr, "d", d);
      }
 
      string fname_split = strdup(cat(fname_dag, "_", i2a(split++)));
      list /* of expression */ lparams = NIL;
 
      _int nout = freia_spoc_pipeline(module, fname_split, code, d, &lparams,
                                      output_images);
      stnb = freia_substitute_by_helper_call(d, global_remainings, remainings,
                                      ls, fname_split, lparams, helpers, stnb);
      // record (simple) signature
      hash_put(init, local_name_to_top_level_entity(fname_split), (void*) nout);
      free(fname_split), fname_split = NULL;
    }
 
    n_spoc_calls += split;
    fprintf(helper_file, "// split %d: %d cut%s\n",
            n_pipes-1, split, split>1? "s": "");
 
    set_free(remainings), remainings = NULL;
    free(fname_dag), fname_dag = NULL;
  }
 
  set_free(stats);
  set_free(dones);
 
  fprintf(helper_file, "// # SPOC calls: %d\n", n_spoc_calls);
 
  freia_insert_added_stats(ls, added_before, true);
  added_before = NIL;
 
  freia_insert_added_stats(ls, added_after, false);
  added_after = NIL;
 
  string_buffer_to_file(code, helper_file);
  string_buffer_free(&code);
 
  // cleanup
  set_free(global_remainings), global_remainings = NULL;
  free(fname_fulldag), fname_fulldag = NULL;
  FOREACH(dag, dc, ld)
    free_dag(dc);
  gen_free_list(ld);
 
  // deal with new images
  list real_new_images =
    freia_allocate_new_images_if_needed(ls, new_images, occs, init, init);
  gen_free_list(new_images);
  hash_table_free(init);
  return real_new_images;
}

Referenced by freia_compile().

Here is the caller graph for this function:

freia_spoc_compiler()

bool freia_spoc_compiler

(

const

string

)

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/hwac/hwac-local.h instead, to add your own modifications. header file built by cproto hwac-local.h cproto-generated files hardware_accelerator.c

Parameters

string

odule

Definition at line 124 of file hardware_accelerator.c.

{
  return freia_compiler(module, "spoc");
}

References freia_compiler(), and module.

Here is the call 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

)

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:

freia_switch_image_in_statement()

void freia_switch_image_in_statement	(	statement	s,
		entity	old,
		entity	img,
		bool	write
	)

switch read or written image in statement if this is an AIPO call, only substitute output or input depending on write otherwise all occurrences are substituted

Parameters

old	ld
img	mg
write	rite

Definition at line 2746 of file dag-utils.c.

{
  swis_ctx ctx = { old, img, write };
  gen_context_multi_recurse(s, &ctx,
                            call_domain, swis_call_flt, gen_null,
                            reference_domain, gen_true, swis_ref_rwt,
                            NULL);
}

References call_domain, gen_context_multi_recurse(), gen_null(), gen_true(), reference_domain, swis_call_flt(), and swis_ref_rwt().

Referenced by freia_allocate_new_images_if_needed(), and switch_image_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_terapix_compiler()

bool freia_terapix_compiler

(

const

string

)

Parameters

string

odule

Definition at line 129 of file hardware_accelerator.c.

{
  return freia_compiler(module, "terapix");
}

References freia_compiler(), and module.

Here is the call graph for this function:

freia_transpose_kernel()

expression freia_transpose_kernel

(

const

expression

)

Transpose a structuring element expression.

Parameters

expression

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:

freia_trpx_compile_calls()

list freia_trpx_compile_calls	(	string	module,
		dag	fulld,
		sequence	sq,
		list	ls,
		const hash_table	occs,
		hash_table	exchanges,
		const set	output_images,
		FILE *	helper_file,
		set	helpers,
		int	number
	)

freia_terapix.c

freia_terapix.c

Parameters

module,current	module (function) name
ls,list	of statements taken from the sequence
occs,occurences	of images (image -> set of statements)
helper_file,file	to which code is to be generated
number,number	of this statement sequence in module

Returns

list of intermediate image to allocate

Parameters

module	odule
fulld	ulld
sq	q
ls	of statements
occs	ccs
exchanges	xchanges
output_images	utput_images
helper_file	elper_file
helpers	elpers
number	umber

Definition at line 1808 of file freia_terapix.c.

{
  bool reduce_cc =
    get_bool_property("HWAC_TERAPIX_REDUCE_TO_CONNECTED_COMPONENTS");
 
  // build DAG for ls
  pips_debug(3, "considering %d statements\n", (int) gen_length(ls));
  pips_assert("some statements", ls);
 
  int n_op_init, n_op_init_copies;
  freia_aipo_count(fulld, &n_op_init, &n_op_init_copies);
 
  // must have distinct images in the graph for optimizations
  hash_table init = hash_table_make(hash_pointer, 0);
  list new_images = dag_fix_image_reuse(fulld, init, occs);
 
  list added_before = NIL, added_after = NIL;
  freia_dag_optimize(fulld, exchanges, &added_before, &added_after);
 
  int n_op_opt, n_op_opt_copies;
  freia_aipo_count(fulld, &n_op_opt, &n_op_opt_copies);
 
  fprintf(helper_file,
          "\n"
          "// dag %d: %d ops and %d copies, "
          "optimized to %d ops and %d+%d+%d copies\n",
          number, n_op_init, n_op_init_copies,
          n_op_opt, n_op_opt_copies,
          (int) gen_length(added_before), (int) gen_length(added_after));
 
  // dump final dag
  dag_dot_dump_prefix(module, "dag_cleaned_", number, fulld,
                      added_before, added_after);
 
  string fname_fulldag = strdup(cat(module, "_terapix", HELPER, i2a(number)));
 
  // First, split only on scalar deps...
  // is it that simple? NO!
  // consider A -> B -> s -> C -> D
  //           \-> E -> F />
  // then ABEF / CD is chosen
  // although ABE / FCD and AB / EFCD would be also possible..
 
  pips_assert("erosion is clean", erosion==NULL);
  erosion = hash_table_make(hash_pointer, 0);
  list ld = dag_split_on_scalars(fulld,
                                 not_implemented,
                                 choose_terapix_vertex,
                                 (gen_cmp_func_t) dagvtx_terapix_priority,
                                 dag_terapix_reset_erosion,
                                 output_images);
  hash_table_free(erosion), erosion = NULL;
 
  // split ld dags by connected components
  if (reduce_cc)
  {
    list nld = NIL;
    FOREACH(dag, d, ld)
      nld = gen_nconc(nld, dag_split_connected_components(d, output_images));
    gen_free_list(ld), ld = nld, nld = NIL;
  }
 
  pips_debug(4, "dag initial split in %d dags\n", (int) gen_length(ld));
 
  const char* dag_cut = get_string_property(trpx_dag_cut);
  pips_assert("valid cutting strategy", trpx_dag_cut_is_valid(dag_cut));
 
  // globally remaining statements
  set global_remainings = set_make(set_pointer);
  set_assign_list(global_remainings, ls);
 
  int n_split = 0;
  int stnb = -1;
  set dones = set_make(set_pointer);
 
  FOREACH(dag, d, ld)
  {
    // ??? should migrate beforehand?
 
    // skip if something is not implemented
    if (terapix_not_implemented(d))
      continue;
 
    if (dag_no_image_operation(d))
      continue;
 
    if (trpx_dag_cut_none_p(dag_cut))
    {
      migrate_statements(sq, d, dones);
      // direct handling of the dag
      stnb = freia_trpx_compile_one_dag(module, ls, d, fname_fulldag, n_split,
                       -1, global_remainings, helper_file, helpers, stnb, init);
    }
    else if (trpx_dag_cut_compute_p(dag_cut))
    {
      // try split dag into subdags with a rough computed strategy
      hash_table erosion = hash_table_make(hash_pointer, 0);
      int cut, n_cut = 0;
 
      // what about another strategy?
      // I can try every possible cuts and chose the best one,
      // that is to stop as soon as computation cost > communication cost?
      // or when costs are quite balanced in all cuts?
      // dag cutting strategy prop = none/computed/optimized?
 
      while ((cut = cut_decision(d, erosion)))
      {
        dag dc = cut_perform(d, cut, erosion, fulld, output_images);
 
        // may separate by connected components...
        list ld;
        if (reduce_cc)
          ld = dag_split_connected_components(dc, output_images);
        else
          ld = CONS(dag, dc, NIL);
 
        FOREACH(dag, dci, ld)
        {
          migrate_statements(sq, dci, dones);
          // generate code for cut
          stnb =
            freia_trpx_compile_one_dag(module, ls, dci, fname_fulldag, n_split,
                 n_cut++, global_remainings, helper_file, helpers, stnb, init);
          // cleanup
          free_dag(dci);
        }
 
        hash_table_clear(erosion);
        gen_free_list(ld);
      }
 
      if (dag_vertices(d)) {
        // should it *ALWAYS* HAPPEN?
        migrate_statements(sq, d, dones);
        stnb = freia_trpx_compile_one_dag(module, ls, d, fname_fulldag, n_split,
               n_cut++, global_remainings, helper_file, helpers, stnb, init);
      }
 
      hash_table_free(erosion);
    }
    else if (trpx_dag_cut_enumerate_p(dag_cut))
      pips_internal_error("not implemented yet");
    else
      pips_internal_error("cannot get there");
 
    n_split++;
  }
 
  freia_insert_added_stats(ls, added_before, true);
  added_before = NIL;
  freia_insert_added_stats(ls, added_after, false);
  added_after = NIL;
 
  // full cleanup
  set_free(global_remainings), global_remainings = NULL;
  free(fname_fulldag), fname_fulldag = NULL;
  FOREACH(dag, dc, ld)
    free_dag(dc);
  gen_free_list(ld);
 
  // deal with new images
  list real_new_images =
    freia_allocate_new_images_if_needed(ls, new_images, occs, init, init);
  gen_free_list(new_images);
  hash_table_free(init);
  return real_new_images;
}

Referenced by freia_compile().

Here is the caller graph for this function:

freia_unroll_while()

bool freia_unroll_while

(

const

string

)

freia_transformations.c

Parameters

string

odule

Definition at line 269 of file freia_transformations.c.

{
  // sanity check
  int factor = get_int_property(spoc_depth_prop);
  if (factor<=1)
  {
    pips_user_warning("cannot unroll with factor=%d\n", factor);
    return true;
  }
 
  // else, do the job
  debug_on("PIPS_HWAC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
 
  // else do the stuff
  statement mod_stat =
    (statement) db_get_memory_resource(DBR_CODE, module, true);
  set_current_module_statement(mod_stat);
  set_current_module_entity(module_name_to_entity(module));
 
  // do the job
  bool changed = freia_unroll_while_for_spoc(mod_stat);
 
  // update if changed
  if (changed)
  {
    stmt_renumber(mod_stat);
    module_reorder(mod_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, mod_stat);
  }
 
  // cleanup
  reset_current_module_statement();
  reset_current_module_entity();
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, freia_unroll_while_for_spoc(), get_int_property(), mod_stat, module, module_name_to_entity(), module_reorder(), pips_debug, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), spoc_depth_prop, and stmt_renumber().

Here is the call 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:

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

)

returns the index of the description of an AIPO function

Parameters

string

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:

is_freia_alloc()

bool is_freia_alloc

(

const

statement

)

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

)

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:

remove_simple_scalar_pointers()

bool remove_simple_scalar_pointers

(

const

string

)

Parameters

string

odule

Definition at line 584 of file freia_transformations.c.

{
  debug_on("PIPS_HWAC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
 
  // else do the stuff
  statement mod_stat =
    (statement) db_get_memory_resource(DBR_CODE, module, true);
  set_current_module_statement(mod_stat);
  set_current_module_entity(module_name_to_entity(module));
 
  rssp_ctx ctx;
  ctx.candidates = set_make(set_pointer);
  ctx.points_to = hash_table_make(hash_pointer, 0);
  ctx.defined = hash_table_make(hash_pointer, 0);
  ctx.dereferenced = hash_table_make(hash_pointer, 0);
  ctx.invalidated = set_make(set_pointer);
 
  // get candidates
  FOREACH(entity, var, entity_declarations(get_current_module_entity()))
  {
    if (pointer_candidate_p(var))
    {
      set_add_element(ctx.candidates, ctx.candidates, var);
      if (value_expression_p(entity_initial(var)))
      {
        expression e = value_expression(entity_initial(var));
        entity v2 = address_of_scalar(e);
        if (v2)
        {
          hash_put(ctx.points_to, var, v2);
          hash_put(ctx.defined, var, expression_call(e));
        }
      }
    }
  }
 
 
  // check condition
  gen_context_multi_recurse
    (mod_stat, &ctx,
     reference_domain, gen_true, rssp_ref,
     // ignore sizeof
     sizeofexpression_domain, gen_false, gen_null,
     NULL);
 
  bool changed = false;
  // apply transformation
  SET_FOREACH(entity, var, ctx.candidates)
  {
    pips_debug(2, "considering entity %s inv=%d dr=%d def=%d pt=%d\n",
               entity_name(var), set_belong_p(ctx.invalidated, var),
               hash_defined_p(ctx.dereferenced, var),
               hash_defined_p(ctx.defined, var),
               hash_defined_p(ctx.points_to, var));
 
    if (!set_belong_p(ctx.invalidated, var) &&
        hash_defined_p(ctx.dereferenced, var) &&
        hash_defined_p(ctx.defined, var) &&
        hash_defined_p(ctx.points_to, var))
    {
      changed = true;
      // replace use
      expression deref = (expression) hash_get(ctx.dereferenced, var);
      expression_syntax(deref) = make_syntax_reference
        (make_reference((entity) hash_get(ctx.points_to, var), NIL));
      // drop definition
      call definition = (call) hash_get(ctx.defined, var);
      gen_free_list(call_arguments(definition)),
        call_arguments(definition) = NIL;
      call_function(definition) = make_integer_constant_entity(0);
      // declaration cleanup?
    }
  }
 
  // result
  if (changed)
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, mod_stat);
 
  // cleanup
  set_free(ctx.candidates);
  set_free(ctx.invalidated);
  hash_table_free(ctx.points_to);
  hash_table_free(ctx.dereferenced);
  hash_table_free(ctx.defined);
  reset_current_module_statement();
  reset_current_module_entity();
  debug_off();
 
  return true;
}

References address_of_scalar(), call_arguments, call_function, rssp_ctx::candidates, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, rssp_ctx::defined, rssp_ctx::dereferenced, entity_declarations, entity_initial, entity_name, expression_call(), expression_syntax, FOREACH, gen_context_multi_recurse(), gen_false(), gen_free_list(), gen_null(), gen_true(), get_current_module_entity(), hash_defined_p(), hash_get(), hash_pointer, hash_put(), hash_table_free(), hash_table_make(), rssp_ctx::invalidated, make_integer_constant_entity(), make_reference(), make_syntax_reference(), mod_stat, module, module_name_to_entity(), NIL, pips_debug, pointer_candidate_p(), rssp_ctx::points_to, reference_domain, reset_current_module_entity(), reset_current_module_statement(), rssp_ref(), set_add_element(), set_belong_p(), set_current_module_entity(), set_current_module_statement(), SET_FOREACH, set_free(), set_make(), set_pointer, sizeofexpression_domain, value_expression, and value_expression_p.

Here is the call graph for this function:

same_constant_parameters()

bool same_constant_parameters	(	const	dagvtx,
		const	dagvtx
	)

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

Parameters

dagvtx	1
dagvtx	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_append_vertex_statements()

void set_append_vertex_statements	(	set	s,
		list	lv
	)

Parameters

lv

v

Definition at line 2385 of file dag-utils.c.

{
  FOREACH(dagvtx, v, lv)
  {
    pstatement ps = vtxcontent_source(dagvtx_content(v));
    if (pstatement_statement_p(ps))
      set_add_element(s, s, pstatement_statement(ps));
  }
}

References dagvtx_content, FOREACH, pstatement_statement, pstatement_statement_p, set_add_element(), 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:

single_image_assignement_p()

bool single_image_assignement_p

(

dag

d

)

??? I'm unsure about what happens to dead code in the pipeline...

??? BUG the code may not work properly when image variable are reused within a pipe. The underlying issues are subtle and would need careful thinking: the initial code is correct, the dag representation is correct, but the generated code may reorder dag vertices so that reused variables are made to interact one with the other. Maybe I should recreate output variables in the generated code for every pipeline. this would imply a cleanup phase to removed unused images at the end. I would really need an SSA form on images? this function checks the assumption before proceeding further.

Definition at line 2217 of file dag-utils.c.

{
  set outs = set_make(set_pointer);
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    vtxcontent c = dagvtx_content(v);
    entity out = vtxcontent_out(c);
    if (out!=entity_undefined)
    {
      if (set_belong_p(outs, out)) {
        set_free(outs);
        return false;
      }
      set_add_element(outs, outs, out);
    }
  }
  set_free(outs);
  return true;
}

References dag_vertices, dagvtx_content, entity_undefined, FOREACH, out, set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, and vtxcontent_out.

Referenced by dag_split_on_scalars().

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: