dag-utils.c File Reference

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

Include dependency graph for dag-utils.c:

Go to the source code of this file.

Data Structures
struct	swis_ctx

Macros
#define	IMG_DEP   ""
#define	SCL_DEP   "arrowhead=empty"
#define	DOT_SUFFIX   ".dot"
#define	aipo_op_p(a, name)    same_string_p(AIPO name, a->function_name)
#define	starts_with(s1, s2)   (strncmp(s1, s2, strlen(s2))==0) /**a la java */

Functions
string	dagvtx_to_string (const dagvtx v)
	dag-utils.c More...
statement	dagvtx_statement (const dagvtx v)
	return statement if any, or NULL (for input nodes). More...
void	dag_statements (set stats, const dag d)
	build the set of actual statements in d More...
bool	dagvtx_other_stuff_p (const dagvtx v)
	a vertex with a non AIPO or image related statement. More...
entity	dagvtx_image (const dagvtx v)
	return the produced image or NULL More...
static void	entity_list_dump (FILE *out, const string what, const list l)
_int	dagvtx_number (const dagvtx v)
	returns the vertex number, i.e. More...
string	dagvtx_number_str (const dagvtx v)
_int	dagvtx_optype (const dagvtx v)
_int	dagvtx_opid (const dagvtx v)
string	dagvtx_function_name (const dagvtx v)
string	dagvtx_operation (const dagvtx v)
string	dagvtx_compact_operation (const dagvtx v)
int	dagvtx_ordering (const dagvtx *v1, const dagvtx *v2)
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. More...
void	dagvtx_nb_dump (FILE *out, const string what, const list l)
void	dagvtx_dump (FILE *out, const string name, const dagvtx v)
	for dag debug. More...
void	dag_dump (FILE *out, const string what, const dag d)
	for dag debug More...
static const char *	entity_dot_name (entity e)
static void	dagvtx_dot_node (FILE *out, const string prefix, const dagvtx v)
static void	dagvtx_dot_node_sb (string_buffer sb, const string prefix, const dagvtx v)
static void	dagvtx_dot (FILE *out, const dag d, const dagvtx vtx)
static void	dagvtx_copy_list_dot (FILE *out, const list ls, const set inputs)
static void	dagvtx_list_dot (FILE *out, const string comment, const list l, const set used)
static bool	dagvtx_is_operator_p (const dagvtx v, const string opname)
static bool	dagvtx_is_copy_p (const dagvtx v)
	returns whether the vertex is an image copy operation. More...
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 More...
void	dag_dot_dump (const string module, const string name, const dag d, const list lb, const list la)
	generate a "dot" format from a dag to a file. More...
void	dag_dot_dump_prefix (const string module, const string prefix, int number, const dag d, const list lb, const list la)
static void	check_removed (const dagvtx v, const dagvtx removed)
static int	dagvtx_cmp_entity (const dagvtx *v1, const dagvtx *v2)
static void	vertex_list_sorted_by_entities (list l)
void	dag_consistency_asserts (dag d)
	do some consistency checking... More...
static void	dag_remove_unused_inputs (dag d)
	remove unused inputs More...
void	dag_remove_vertex (dag d, const dagvtx v)
	remove vertex v from dag d. More...
dagvtx	copy_dagvtx_norec (dagvtx v)
	copy a vertex, but without its successors. More...
bool	dagvtx_is_measurement_p (const dagvtx v)
	returns whether the vertex is an image measurement operation. More...
void	dag_append_vertex (dag d, dagvtx nv)
	append new vertex nv to dag d. More...
int	dag_computation_count (const dag d)
	return the number of actual operations in dag d. More...
list	dag_vertex_preds (const dag d, const dagvtx target)
	return target predecessor vertices as a list. More...
static bool	gen_list_equals_p (const list l1, const list l2)
static bool	switch_vertex_to_assign (dagvtx target, dagvtx source)
	replace target measure to a copy of source result... More...
static void	substitute_image_in_statement (dagvtx v, entity source, entity target, bool used)
	subtitute produced or used image in the statement of vertex v. More...
static void	switch_vertex_to_a_copy (dagvtx target, dagvtx source, list tpreds)
	replace target vertex by a copy of source results... More...
static bool	same_operation_p (const dagvtx v1, const dagvtx v2)
static bool	commutative_operation_p (const dagvtx v1, const dagvtx v2)
static bool	list_commuted_p (const list l1, const list l2)
static void	unlink_copy_vertex (dag d, const entity source, dagvtx copy)
	"copy" copies "source" image in dag "d". More...
static bool	all_vertices_are_copies_or_measures_p (const list lv)
static int	number_of_copies (list l)
static expression	compute_constant (string op, expression val1, expression val2)
	compute a constant expression for FREIA ??? TODO partial eval if values are constant More...
static void	set_aipo_call (dagvtx v, string name, entity img, expression val)
	switch vertex statement to an aipo call More...
static void	set_aipo_copy (dagvtx v, entity e)
	switch vertex to a copy of an image More...
static bool	propagate_constant_image (dagvtx v, entity image, expression val)
	recursively propagate a constant image on a vertex More...
static void	set_aipo_constant (dagvtx v, expression val)
	set vertex as a constant image and propagate to successors More...
static expression	constant_image_p (dagvtx v)
	whether vertex generates a constant image More...
static entity	copy_image_p (dagvtx v)
	tell whether vertex can be assimilated to a copy e.g. More...
static void	propagate_constant_image_to_succs (dagvtx v, expression val)
	propagate constant image to vertex successors More...
static bool	dag_simplify (dag d)
	apply basic algebraic simplification to dag More...
static bool	dag_normalize (dag d)
	normalize, that is use less image operators only transformation is: sub_const(i, v) -> add_const(i, -v) More...
static int	compatible_reduction_operation (const dagvtx v1, const dagvtx v2)
void	freia_dag_optimize (dag d, hash_table exchanges, list *lbefore, list *lafter)
	remove dead image operations. More...
static bool	all_mesures_p (list lv)
	return whether all vertices in list are mesures... More...
static set	dag_stats (dag d)
static bool	any_use_statement (set stats)
	hmmm... More...
static bool	other_significant_uses (entity e, const hash_table occs, const set stats)
static bool	variable_used_as_later_input (entity img, list ld)
	hmmm... More...
static bool	dag_image_is_an_input (dag d, entity img)
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. More...
static dagvtx	find_twin_vertex (dag d, dagvtx target)
void	freia_hack_fix_global_ins_outs (dag dfull, dag d)
	catch some cases of missing outs between splits... More...
void	dag_cleanup_other_statements (dag d)
	remove unneeded statements? you must know they are really un-needed! More...
bool	single_image_assignement_p (dag d)
	??? I'm unsure about what happens to dead code in the pipeline... More...
static bool	any_scalar_dep (dagvtx v, set vs)
	returns whether there is a scalar RW dependency from any vs to v More...
static bool	all_previous_stats_with_deps_are_computed (dag d, const set computed, dagvtx v)
	check scalar dependency from computed to v. More...
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. More...
void	set_append_vertex_statements (set s, list lv)
static list	fs_expression_list_to_entity_list (list args, int nargs)
	convert the first n items in list args to entities. More...
static entity	extract_fist_item (list *lp)
	extract first entity item from list. More...
static void	dag_append_freia_call (dag d, statement s)
	append statement s to dag d More...
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. More...
bool	dag_no_image_operation (dag d)
	tell whether we have something to do with images ??? hmmm... More...
entity	clone_variable_with_new_name (entity, const char *, const char *)
	This function build and return new variable from a variable a_variable, with name new_name. More...
string	compilation_unit_of_module (const char *)
	The output is undefined if the module is referenced but not defined in the workspace, for instance because its code should be synthesized. More...
static entity	freia_data2d_field (string field)
static expression	do_point_to (entity var, string field_name)
static bool	image_ref_flt (reference r, entity *image)
static entity	get_upper_model (entity model, const hash_table occs)
statement	freia_memory_management_statement (entity image, const hash_table occs, bool alloc)
static entity	new_local_image_variable (entity model, const hash_table occs)
static void	swis_ref_rwt (reference r, swis_ctx *ctx)
static bool	swis_call_flt (call c, swis_ctx *ctx)
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 More...
static void	switch_image_variable (dagvtx v, entity old, entity img)
	switch to new image variable in v & its direct successors More...
list	dag_fix_image_reuse (dag d, hash_table init, const hash_table occs)
	fix intermediate image reuse in dag More...
list	dag_split_on_scalars (const dag initial, bool(*alone_only)(const dagvtx), dagvtx(*choose_vertex)(const list, bool), gen_cmp_func_t priority, void(*priority_update)(const dag), const set output_images)
	split a dag on scalar dependencies only, with a greedy heuristics. More...
static string	dagvtx_nb (const void *s)
list	dag_connected_component (dag d, list *plv, bool(*compat)(const dagvtx, const set, const dag))
	extract a sublist of lv which is a connected component. More...
static list	copy_vertices (list lv)
list	dag_split_connected_components (dag d, set output_images)
	build connected components More...

Macro Definition Documentation

aipo_op_p

#define aipo_op_p	(		a,
			name
	)		same_string_p(AIPO name, a->function_name)

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

DOT_SUFFIX

#define DOT_SUFFIX   ".dot"

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

IMG_DEP

#define IMG_DEP   ""

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

SCL_DEP

#define SCL_DEP   "arrowhead=empty"

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

starts_with

#define starts_with	(		s1,
			s2
	)		(strncmp(s1, s2, strlen(s2))==0) /**a la java */

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

Function Documentation

all_mesures_p()

static bool all_mesures_p ( list  lv )

static

return whether all vertices in list are mesures...

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

{
  bool only_mes = true;
  FOREACH(dagvtx, v, lv)
  {
    if (dagvtx_optype(v)!=spoc_type_mes)
    {
      only_mes = false;
      break;
    }
  }
  return only_mes;
}

References dagvtx_optype(), FOREACH, and spoc_type_mes.

Referenced by dag_compute_outputs().

Here is the call graph for this function:

Here is the caller graph for this function:

all_previous_stats_with_deps_are_computed()

static bool all_previous_stats_with_deps_are_computed ( dag  d, const set  computed, dagvtx  v  )

static

check scalar dependency from computed to v.

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

{
  bool okay = true;
 
  // scan in statement order... does it matter?
  list lv = gen_nreverse(gen_copy_seq(dag_vertices(d)));
  FOREACH(dagvtx, pv, lv)
  {
    // all previous have been scanned
    if (pv==v) break;
    if (freia_scalar_rw_dep(dagvtx_statement(pv), dagvtx_statement(v), NULL) &&
        !set_belong_p(computed, pv))
    {
      okay = false;
      break;
    }
  }
  gen_free_list(lv);
 
  pips_debug(8, "all %d deps are okay: %s\n",
             (int) dagvtx_number(v), bool_to_string(okay));
  return okay;
}

References bool_to_string(), dag_vertices, dagvtx_number(), dagvtx_statement(), FOREACH, freia_scalar_rw_dep(), gen_copy_seq(), gen_free_list(), gen_nreverse(), pips_debug, and set_belong_p().

Referenced by dag_computable_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

all_vertices_are_copies_or_measures_p()

static bool all_vertices_are_copies_or_measures_p ( const list  lv )

static

Returns

whether all vertices in list "lv" are copies.

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

{
  FOREACH(dagvtx, v, lv)
    if (!(dagvtx_is_copy_p(v) || dagvtx_is_measurement_p(v)))
      return false;
  return true;
}

References dagvtx_is_copy_p(), dagvtx_is_measurement_p(), and FOREACH.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

any_scalar_dep()

static bool any_scalar_dep ( dagvtx  v, set  vs  )

static

returns whether there is a scalar RW dependency from any vs to v

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

{
  bool dep = false;
  statement target = dagvtx_statement(v);
 
  // hmmm... may be called on a input node
  if (!target) return dep;
 
  SET_FOREACH(dagvtx, source, vs)
  {
    if (source==v)
      continue;
 
    pips_debug(9, "%"_intFMT" rw dep to %"_intFMT"?\n",
               dagvtx_number(source), statement_number(target));
    if (freia_scalar_rw_dep(dagvtx_statement(source), target, NULL))
    {
      dep = true;
      break;
    }
  }
 
  ifdebug(8) {
    string svs = set_to_string("vs", vs, (gen_string_func_t) dagvtx_number_str);
    pips_debug(8, "scalar rw dep on %d for (%s): %s\n",
             (int) dagvtx_number(v), svs, bool_to_string(dep));
    free(svs);
  }
 
  return dep;
}

References _intFMT, bool_to_string(), dagvtx_number(), dagvtx_number_str(), dagvtx_statement(), free(), freia_scalar_rw_dep(), ifdebug, pips_debug, SET_FOREACH, set_to_string(), and statement_number.

Referenced by dag_computable_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

any_use_statement()

static bool any_use_statement ( set  stats )

static

hmmm...

this is poor, should rather rely on use-def chains.

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

{
  bool used = false;
  SET_FOREACH(statement, s, stats)
  {
    call c = freia_statement_to_call(s);
    if (c) {
      const char* name = entity_local_name(call_function(c));
      pips_debug(9, "call to %s\n", name);
      // some freia utils are considered harmless,
      // others imply an actual "use"
      if (!same_string_p(name, FREIA_FREE) &&
          !same_string_p(name, FREIA_ALLOC) &&
          !same_string_p(name, "freia_common_rx_image"))
        used = true;
    }
  }
  return used;
}

References call_function, entity_local_name(), FREIA_ALLOC, FREIA_FREE, freia_statement_to_call(), pips_debug, same_string_p, and SET_FOREACH.

Referenced by other_significant_uses().

Here is the call graph for this function:

Here is the caller graph for this function:

check_removed()

static void check_removed ( const dagvtx  v, const dagvtx  removed  )

static

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

{
  pips_assert("not removed vertex", v!=removed);
}

References pips_assert.

Referenced by dag_remove_vertex(), and freia_dag_optimize().

Here is the caller graph for this function:

clone_variable_with_new_name()

entity clone_variable_with_new_name	(	entity	a_variable,
		const char *	new_name,
		const char *	module_name
	)

This function build and return new variable from a variable a_variable, with name new_name.

If an entity called new_name already exists, return NULL. New variable is added to declarations

Assert that module represent a value code

This entity does not exist, we can safely create it

new_variable = copy_entity (a_variable); entity_name(new_variable) = strdup(concatenate(module_name, MODULE_SEP_STRING, new_name, NULL));

ew_variable = find_or_create_scalar_entity (strdup(concatenate(module_name, MODULE_SEP_STRING, new_name, NULL)),module_name, is_basic_int);

This entity already exist, we return null

Definition at line 269 of file phrase_tools.c.

{
  entity module;
  entity new_variable;
 
  module = module_name_to_entity(module_name);
  /* Assert that module represent a value code */
  pips_assert("it is a code", value_code_p(entity_initial(module)));
 
  if ((gen_find_tabulated(concatenate(module_name,
                                      MODULE_SEP_STRING,
                                      new_name,
                                      NULL),
                          entity_domain)) == entity_undefined)
    {
      /* This entity does not exist, we can safely create it */
     
      /* new_variable = copy_entity (a_variable);
         entity_name(new_variable) 
         = strdup(concatenate(module_name,
         MODULE_SEP_STRING,
         new_name, NULL)); */
     
      new_variable = make_entity (strdup(concatenate(module_name,
                                                     MODULE_SEP_STRING,
                                                     new_name, NULL)),
                                  copy_type (entity_type(a_variable)),
                                  copy_storage (entity_storage(a_variable)),
                                  copy_value (entity_initial(a_variable)));
     
      /*new_variable
        = find_or_create_scalar_entity (strdup(concatenate(module_name,
        MODULE_SEP_STRING,
        new_name, NULL)),module_name,
        is_basic_int);*/
     
      AddEntityToDeclarations(new_variable,module);
      return new_variable;
    }
  else
    {
      /* This entity already exist, we return null */
      return NULL;
    }
}

References a_variable, AddEntityToDeclarations(), concatenate(), copy_storage(), copy_type(), copy_value(), entity_domain, entity_initial, entity_storage, entity_type, entity_undefined, gen_find_tabulated(), make_entity, module, module_name(), module_name_to_entity(), MODULE_SEP_STRING, new_variable, pips_assert, strdup(), and value_code_p.

Referenced by new_local_image_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

commutative_operation_p()

static bool commutative_operation_p ( const dagvtx  v1, const dagvtx  v2  )

static

Returns

whether two vertices are commutors

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

{
  if (dagvtx_optype(v1) == dagvtx_optype(v2))
  {
    int n1 = (int) dagvtx_opid(v1), n2 = (int) dagvtx_opid(v2);
    const freia_api_t * f1 = get_freia_api(n1);
    return f1->commutator && hwac_freia_api_index(f1->commutator)==n2;
  }
  else return false;
}

References freia_api_t::commutator, dagvtx_opid(), dagvtx_optype(), get_freia_api(), hwac_freia_api_index(), and int.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

compatible_reduction_operation()

static int compatible_reduction_operation ( const dagvtx  v1, const dagvtx  v2  )

static

Returns

0 keep both, 1 keep first, 2 keep second

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

{
  const string
    o1 = dagvtx_compact_operation(v1),
    o2 = dagvtx_compact_operation(v2);
  if ((same_string_p(o1, "max!") && same_string_p(o2, "max")) ||
      (same_string_p(o1, "min!") && same_string_p(o2, "min")))
    return 1;
  else if ((same_string_p(o1, "max") && same_string_p(o2, "max!")) ||
           (same_string_p(o1, "min") && same_string_p(o2, "min!")))
    return 2;
  else
    return 0;
}

References dagvtx_compact_operation(), and same_string_p.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

compilation_unit_of_module()

string compilation_unit_of_module

(

const char *

module_name

)

The output is undefined if the module is referenced but not defined in the workspace, for instance because its code should be synthesized.

Fabien Coelho suggests to build a default compilation unit where all synthesized module codes would be located.

Definition at line 350 of file module.c.

{
  entity e = module_name_to_entity(module_name);
  pips_assert("only for C modules\n", entity_undefined_p(e) || c_module_p(e));
 
  // Should only be called for C modules.
  string compilation_unit_name = string_undefined;
 
  // The guard may not be sufficient...
  // and this may crash in db_get_memory_resource()
  if(db_resource_p(DBR_USER_FILE, module_name)) {
    string source_file_name =
      db_get_memory_resource(DBR_USER_FILE, module_name, true);
    string simpler_file_name = pips_basename(source_file_name, PP_C_ED);
 
    // It is not clear how robust it is going to be
    // when file name conflicts occur.
    (void) asprintf(&compilation_unit_name, "%s" FILE_SEP_STRING,
                    simpler_file_name);
    free(simpler_file_name);
  }
 
  return compilation_unit_name;
}

References asprintf, c_module_p(), compilation_unit_name, db_get_memory_resource(), db_resource_p(), entity_undefined_p, FILE_SEP_STRING, free(), module_name(), module_name_to_entity(), pips_assert, pips_basename(), and string_undefined.

Referenced by actual_c_parser(), add_new_module_from_text(), build_real_resources(), cast_STEP_ARG(), create_module_with_statement(), entity_from_user_name(), entity_more_or_less_minimal_name(), freia_data2d_field(), generic_initializer(), inline_expression_call(), linearize_array_generic(), normalize_microcode(), outliner_file(), outliner_scan(), sort_parameters(), step_compile_generated_module(), step_parameter(), string_to_entity(), and update_referenced_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_constant()

static expression compute_constant ( string  op, expression  val1, expression  val2  )

static

compute a constant expression for FREIA ??? TODO partial eval if values are constant

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

{
  // rough! could/should do some partial evaluation here
  entity eop = local_name_to_top_level_entity(op);
  pips_assert("operator function found", eop!=entity_undefined);
  call c = make_call(eop,
                     CONS(expression, copy_expression(val1),
                          CONS(expression, copy_expression(val2), NIL)));
  return call_to_expression(c);
}

References call_to_expression(), CONS, copy_expression(), entity_undefined, local_name_to_top_level_entity(), make_call(), NIL, and pips_assert.

Referenced by propagate_constant_image().

Here is the call graph for this function:

Here is the caller graph for this function:

constant_image_p()

static expression constant_image_p ( dagvtx  v )

static

whether vertex generates a constant image

Parameters

v	vertex to consider

Returns

constant allocated expression or NULL

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

{
  vtxcontent c = dagvtx_content(v);
  _int op = vtxcontent_opid(c);
  const freia_api_t * api = get_freia_api(op);
  if (api->arg_img_in==2)
  {
    pips_assert("2 input images", gen_length(vtxcontent_inputs(c))==2);
    entity e1 = ENTITY(CAR(vtxcontent_inputs(c))),
      e2 = ENTITY(CAR(CDR(vtxcontent_inputs(c))));
    if (e1==e2 && (aipo_op_p(api, "sub") || aipo_op_p(api, "xor")))
      return int_to_expression(0);
    if (e1==e2 && aipo_op_p(api, "div"))
      return int_to_expression(1);
  }
  else if (api->arg_img_in==1)
  {
    bool
      erosion = aipo_op_p(api, "erode_8c") || aipo_op_p(api, "erode_6c"),
      dilatation = aipo_op_p(api, "dilate_8c") || aipo_op_p(api, "dilate_6c");
    // aipo_op_p(api, "convolution") 3x3?
    if (erosion || dilatation)
    {
      _int i00, i10, i20, i01, i11, i21, i02, i12, i22;
      if (freia_extract_kernel_vtx(v, true, &i00, &i10, &i20,
                                   &i01, &i11, &i21, &i02, &i12, &i22))
      {
        // zero boundary
        if (i00==0 && i10==0 && i20==0 && i01==0 &&
            i21==0 && i02==0 && i12==0 && i22==0)
        {
          if (i11==0)
          {
            if (erosion)
              return int_to_expression(0);
            else if (dilatation)
              return int_to_expression(freia_max_pixel_value());
          }
        }
      }
    }
    else if (api->arg_misc_in==1) // arith cst op
    {
      expression e1 = freia_get_nth_scalar_param(v, 1);
      _int val;
      if (expression_integer_value(e1, &val))
      {
        if ((aipo_op_p(api, "mul_const") && val==0) ||
            (aipo_op_p(api, "and_const") && val==0) ||
            (aipo_op_p(api, "inf_const") && val==0) ||
            (aipo_op_p(api, "const_div") && val==0))
          return int_to_expression(val);
 
        int maxval = freia_max_pixel_value();
        if ((aipo_op_p(api, "sup_const") && val==maxval) ||
            (aipo_op_p(api, "or_const") && val==maxval) ||
            (aipo_op_p(api, "addsat_const") && val==maxval))
          return int_to_expression(val);
 
        if ((aipo_op_p(api, "subsat_const") && val==maxval))
          return int_to_expression(0);
      }
    }
  }
  else if (api->arg_img_in==0)
  {
    if (aipo_op_p(api, "set_constant"))
      return copy_expression(freia_get_nth_scalar_param(v, 1));
  }
  return NULL;
}

References aipo_op_p, freia_api_t::arg_img_in, freia_api_t::arg_misc_in, CAR, CDR, copy_expression(), dagvtx_content, ENTITY, erosion, expression_integer_value(), freia_extract_kernel_vtx(), freia_get_nth_scalar_param(), freia_max_pixel_value(), gen_length(), get_freia_api(), int_to_expression(), pips_assert, vtxcontent_inputs, and vtxcontent_opid.

Referenced by dag_simplify().

Here is the call graph for this function:

Here is the caller graph for this function:

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:

copy_image_p()

static entity copy_image_p ( dagvtx  v )

static

tell whether vertex can be assimilated to a copy e.g.

i+.0 i*.1 i/.1 i|.0 i-.0 i&i i|i i>i i<i

Returns

image to copy, or NULL

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

{
  vtxcontent c = dagvtx_content(v);
  _int op = vtxcontent_opid(c);
  const freia_api_t * api = get_freia_api(op);
  if (api->arg_img_in==2)
  {
    pips_assert("2 input images", gen_length(vtxcontent_inputs(c))==2);
    entity e1 = ENTITY(CAR(vtxcontent_inputs(c))),
      e2 = ENTITY(CAR(CDR(vtxcontent_inputs(c))));
    if (e1==e2 && (aipo_op_p(api, "and") ||
                   aipo_op_p(api, "or") ||
                   aipo_op_p(api, "sup") ||
                   aipo_op_p(api, "inf")))
      return e1;
  }
  else if (api->arg_img_in==1)
  {
    if (aipo_op_p(api, "erode_8c") ||
        aipo_op_p(api, "erode_6c") ||
        aipo_op_p(api, "dilate_8c") ||
        aipo_op_p(api, "dilate_6c"))
        // aipo_op_p(api, "convolution") 3x3?
    {
      _int i00, i10, i20, i01, i11, i21, i02, i12, i22;
      if (freia_extract_kernel_vtx(v, true, &i00, &i10, &i20,
                                   &i01, &i11, &i21, &i02, &i12, &i22))
      {
        // zero boundary
        if (i00==0 && i10==0 && i20==0 && i01==0 &&
            i21==0 && i02==0 && i12==0 && i22==0)
        {
          if (i11==1) return ENTITY(CAR(vtxcontent_inputs(c)));
        }
      }
    }
    else if (api->arg_misc_in==1)
    {
      expression e1 = freia_get_nth_scalar_param(v, 1);
      _int val;
      if (expression_integer_value(e1, &val))
      {
        if ((aipo_op_p(api, "mul_const") && val==1) ||
            (aipo_op_p(api, "div_const") && val==1) ||
            (aipo_op_p(api, "or_const") && val==0) ||
            (aipo_op_p(api, "add_const") && val==0) ||
            (aipo_op_p(api, "sub_const") && val==0) ||
            (aipo_op_p(api, "sup_const") && val==0))
          return ENTITY(CAR(vtxcontent_inputs(c)));
 
        int maxval = freia_max_pixel_value();
        if ((aipo_op_p(api, "inf_const") && val==maxval) ||
            (aipo_op_p(api, "addsat") && val==maxval))
          return ENTITY(CAR(vtxcontent_inputs(c)));
      }
    }
    else if (api->arg_misc_in==0)
    {
      if (aipo_op_p(api, "copy"))
        return ENTITY(CAR(vtxcontent_inputs(c)));
    }
  }
  return NULL;
}

References aipo_op_p, freia_api_t::arg_img_in, freia_api_t::arg_misc_in, CAR, CDR, dagvtx_content, ENTITY, expression_integer_value(), freia_extract_kernel_vtx(), freia_get_nth_scalar_param(), freia_max_pixel_value(), gen_length(), get_freia_api(), pips_assert, vtxcontent_inputs, and vtxcontent_opid.

Referenced by dag_simplify(), and propagate_constant_image().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_vertices()

static list copy_vertices ( list  lv )

static

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

{
  list nl = NIL;
  FOREACH(dagvtx, v, lv)
    if (dagvtx_number(v)!=0)
      nl = CONS(dagvtx, v, nl);
  return gen_nreverse(nl);
}

References CONS, dagvtx_number(), FOREACH, gen_nreverse(), and NIL.

Referenced by dag_split_connected_components().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_append_freia_call()

static void dag_append_freia_call ( dag  d, statement  s  )

static

append statement s to dag d

of entity

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

{
  pips_debug(5, "adding statement %" _intFMT "\n", statement_number(s));
 
  call c = freia_statement_to_call(s);
 
  if (c && entity_freia_api_p(call_function(c)))
  {
    entity called = call_function(c);
    const freia_api_t * api = hwac_freia_api(entity_local_name(called));
    pips_assert("some api", api!=NULL);
    list /* of entity */ args =
      fs_expression_list_to_entity_list(call_arguments(c),
          api->arg_img_in+api->arg_img_out);
 
    // extract arguments
    entity out = entity_undefined;
    pips_assert("one out image max for an AIPO", api->arg_img_out<=1);
    if (api->arg_img_out==1)
      out = extract_fist_item(&args);
    list ins = gen_list_head(&args, api->arg_img_in);
    pips_assert("no more arguments", gen_length(args)==0);
 
    vtxcontent cont =
      make_vtxcontent(-1, 0, make_pstatement_statement(s), ins, out);
    freia_spoc_set_operation
      (api, &vtxcontent_optype(cont), &vtxcontent_opid(cont));
 
    dagvtx nv = make_dagvtx(cont, NIL);
    dag_append_vertex(d, nv);
  }
  else // some other kind of statement that we may keep in the DAG
  {
    dagvtx nv =
      make_dagvtx(make_vtxcontent(spoc_type_oth, 0,
    make_pstatement_statement(s), NIL, entity_undefined), NIL);
    dag_vertices(d) = CONS(dagvtx, nv, dag_vertices(d));
  }
}

References _intFMT, freia_api_t::arg_img_in, freia_api_t::arg_img_out, call_arguments, call_function, CONS, dag_append_vertex(), dag_vertices, entity_freia_api_p(), entity_local_name(), entity_undefined, extract_fist_item(), freia_spoc_set_operation(), freia_statement_to_call(), fs_expression_list_to_entity_list(), gen_length(), gen_list_head(), hwac_freia_api(), make_dagvtx(), make_pstatement_statement(), make_vtxcontent(), NIL, out, pips_assert, pips_debug, spoc_type_oth, statement_number, vtxcontent_opid, and vtxcontent_optype.

Referenced by freia_build_dag().

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	module,
		const string	name,
		const dag	d,
		const list	lb,
		const list	la
	)

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

Parameters

module	odule
name	ame
lb	b
la	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	module,
		const string	prefix,
		int	number,
		const dag	d,
		const list	lb,
		const list	la
	)

Parameters

module	odule
prefix	refix
number	umber
lb	b
la	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	what,
		const dag	d
	)

for dag debug

Parameters

out	ut
what	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_image_is_an_input()

static bool dag_image_is_an_input ( dag  d, entity  img  )

static

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

{
  bool is_input = false;
  FOREACH(dagvtx, v, dag_inputs(d))
  {
    if (dagvtx_image(v)==img)
    {
      is_input = true;
      break;
    }
  }
 
  pips_debug(4, "image %s input: %s\n",
             entity_name(img), bool_to_string(is_input));
 
  return is_input;
}

References bool_to_string(), dag_inputs, dagvtx_image(), entity_name, FOREACH, and pips_debug.

Referenced by dag_compute_outputs().

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

static bool dag_normalize ( dag  d )

static

normalize, that is use less image operators only transformation is: sub_const(i, v) -> add_const(i, -v)

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

{
  bool changed = false;
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    vtxcontent ct = dagvtx_content(v);
    statement s = dagvtx_statement(v);
    call c = s? freia_statement_to_call(s): NULL;
    if (c)
    {
      list args = call_arguments(c);
      entity func = call_function(c);
      if (same_string_p(entity_local_name(func), AIPO "sub_const"))
      {
        changed = true;
        // sub_const -> add_const(opposite)
        // does it always make sense for unsigned pixels?
        vtxcontent_opid(ct) = hwac_freia_api_index(AIPO "add_const");
        call_function(c) = local_name_to_top_level_entity(AIPO "add_const");
        list l3 = CDR(CDR(args));
        _int v;
        if (expression_integer_value(EXPRESSION(CAR(l3)), &v))
        {
          // partial eval
          free_expression(EXPRESSION(CAR(l3)));
          EXPRESSION_(CAR(l3)) = int_to_expression(-v);
        }
        else
        {
          // symbolic
          EXPRESSION_(CAR(l3)) =
            MakeUnaryCall(
              local_name_to_top_level_entity(UNARY_MINUS_OPERATOR_NAME),
              EXPRESSION(CAR(l3)));
        }
      }
      // what else?
    }
  }
  return changed;
}

References AIPO, call_arguments, call_function, CAR, CDR, dag_vertices, dagvtx_content, dagvtx_statement(), entity_local_name(), EXPRESSION, EXPRESSION_, expression_integer_value(), FOREACH, free_expression(), freia_statement_to_call(), hwac_freia_api_index(), int_to_expression(), local_name_to_top_level_entity(), MakeUnaryCall(), same_string_p, UNARY_MINUS_OPERATOR_NAME, and vtxcontent_opid.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_remove_unused_inputs()

static void dag_remove_unused_inputs ( dag  d )

static

remove unused inputs

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

{
  list nl = NIL;
  FOREACH(dagvtx, v, dag_inputs(d))
  {
    if (dagvtx_succs(v)!=NIL) // do we keep it?
      nl = CONS(dagvtx, v, nl);
    else
      gen_remove(&dag_vertices(d), v);
      // ??? memory leak? there may be "pointers" somewhere to these?
      // free_dagvtx(v);
  }
  if (dag_inputs(d)) gen_free_list(dag_inputs(d));
  dag_inputs(d) = gen_nreverse(nl);
}

References CONS, dag_inputs, dag_vertices, dagvtx_succs, FOREACH, gen_free_list(), gen_nreverse(), gen_remove(), and NIL.

Referenced by dag_remove_vertex().

Here is the call graph for this function:

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

static bool dag_simplify ( dag  d )

static

apply basic algebraic simplification to dag

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

{
  bool changed = false;
 
  // propagate constants and detect copies
  FOREACH(dagvtx, v, dag_vertices(d))
  {
    expression val;
    entity img;
    if ((val=constant_image_p(v))!=NULL)
    {
      changed = true;
 
      // fix successors of predecessors of new "constant" operation
      list preds = dag_vertex_preds(d, v);
      FOREACH(dagvtx, p, preds)
        gen_remove(&dagvtx_succs(p), v);
      gen_free_list(preds);
 
      // swich operation to constant
      set_aipo_constant(v, val);
      free_expression(val);
    }
    else if ((img=copy_image_p(v))!=NULL)
    {
      changed = true;
      set_aipo_copy(v, img);
    }
    // another one just for fun: I+I -> 2*I
    // this is good for SPoC
    else if (dagvtx_is_operator_p(v, "add"))
    {
      list preds = dag_vertex_preds(d, v);
      pips_assert("two args to add", gen_length(preds)==2);
      if (DAGVTX(CAR(preds))==DAGVTX(CAR(CDR(preds))))
      {
        changed = true;
        set_aipo_call(v, "mul_const",
                      dagvtx_image(DAGVTX(CAR(preds))), int_to_expression(2));
      }
    }
  }
 
  return changed;
}

References CAR, CDR, constant_image_p(), copy_image_p(), dag_vertex_preds(), dag_vertices, DAGVTX, dagvtx_image(), dagvtx_is_operator_p(), dagvtx_succs, FOREACH, free_expression(), gen_free_list(), gen_length(), gen_remove(), int_to_expression(), pips_assert, set_aipo_call(), set_aipo_constant(), and set_aipo_copy().

Referenced by freia_dag_optimize().

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	d
	)

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

static set dag_stats ( dag  d )

static

Returns

the set of all statements in dag

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

{
  set stats = set_make(set_pointer);
  statement s;
  FOREACH(dagvtx, v, dag_vertices(d))
    if ((s = dagvtx_statement(v)))
      set_add_element(stats, stats, s);
  return stats;
}

References dag_vertices, dagvtx_statement(), FOREACH, set_add_element(), set_make(), and set_pointer.

Referenced by dag_compute_outputs().

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

static int dagvtx_cmp_entity ( const dagvtx *  v1, const dagvtx *  v2  )

static

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

{
  return compare_entities(&vtxcontent_out(dagvtx_content(*v1)),
        &vtxcontent_out(dagvtx_content(*v2)));
}

References compare_entities(), dagvtx_content, and vtxcontent_out.

Referenced by vertex_list_sorted_by_entities().

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

v

)

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

static void dagvtx_copy_list_dot ( FILE *  out, const list  ls, const set  inputs  )

static

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

{
  FOREACH(statement, s, ls)
  {
    call c = freia_statement_to_call(s);
    if (c && same_string_p(entity_local_name(call_function(c)), AIPO "copy"))
    {
      list args = call_arguments(c);
      pips_assert("two args to aipo copy", gen_length(args)==2);
      entity dst = expression_to_entity(EXPRESSION(CAR(args)));
      entity src = expression_to_entity(EXPRESSION(CAR(CDR(args))));
      fprintf(out,
              "  \"%s%s\" [shape=circle];\n"
              "  \"%s =\" [shape=circle,label=\"=\",style=\"dashed\"]\n"
              "  \"%s%s\" -> \"%s =\";\n"
              "  \"%s =\" -> \"%s%s\";\n",
              entity_dot_name(dst), set_belong_p(inputs, dst)? "'": "",
              entity_dot_name(dst),
              entity_dot_name(src), set_belong_p(inputs, src)? "'": "",
              entity_dot_name(dst), entity_dot_name(dst),
              entity_dot_name(dst), set_belong_p(inputs, dst)? "'": "");
    }
    // should not be a else?
  }
}

References AIPO, call_arguments, call_function, CAR, CDR, entity_dot_name(), entity_local_name(), EXPRESSION, expression_to_entity(), FOREACH, fprintf(), freia_statement_to_call(), gen_length(), out, pips_assert, same_string_p, set_belong_p(), and src.

Referenced by dag_dot().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_dot()

static void dagvtx_dot ( FILE *  out, const dag  d, const dagvtx  vtx  )

static

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

{
  // collect prettyprint properties
  bool label_nodes = get_bool_property("FREIA_DAG_LABEL_NODES");
  bool show_arcs = get_bool_property("FREIA_DAG_LABEL_ARCS");
  bool filter_nodes = get_bool_property("FREIA_DAG_FILTER_NODES");
 
  vtxcontent co = dagvtx_content(vtx);
  const char* vname = NULL;
  if (vtxcontent_out(co)!=entity_undefined)
    vname = entity_dot_name(vtxcontent_out(co));
 
  if (dagvtx_number(vtx)==0)
  {
    // this is an input image, only image dependencies
    FOREACH(dagvtx, succ, dagvtx_succs(vtx))
    {
      fprintf(out, "  \"%s\"", vname);
      dagvtx_dot_node(out, " -> ", succ);
      fprintf(out, ";\n");
    }
  }
  else
  {
    // we are dealing with a computation...
    string attribute = what_operation_shape(vtxcontent_optype(co));
    string_buffer sa = string_buffer_make(true);
    bool some_arcs = false;
 
    // first check for image dependencies
    FOREACH(dagvtx, succ, dagvtx_succs(vtx))
    {
      dagvtx_dot_node_sb(sa, "  ", vtx);
      dagvtx_dot_node_sb(sa, " -> ", succ);
      sb_cat(sa, show_arcs? " [label=\"": "",
             show_arcs? vname: "", show_arcs? "\"]": "", ";\n");
      some_arcs = true;
    }
 
    // then scalar dependencies anywhere... hmmm...
    FOREACH(dagvtx, v, dag_vertices(d))
    {
      list vars = NIL;
      if (// another vertex
          vtx!=v &&
          // with dependencies
          freia_scalar_rw_dep(dagvtx_statement(vtx),
                              dagvtx_statement(v), &vars))
      {
        // show scalar dep in sequence order
        if (dagvtx_number(v)>dagvtx_number(vtx))
        {
          dagvtx_dot_node_sb(sa, "  ", vtx);
          dagvtx_dot_node_sb(sa, " -> ", v);
        }
        else
        {
          dagvtx_dot_node_sb(sa, "  ", v);
          dagvtx_dot_node_sb(sa, " -> ", vtx);
        }
 
        sb_cat(sa, " [" SCL_DEP);
 
        if (vars && show_arcs)
        {
          int count = 0;
          sb_cat(sa, ",label=\"");
          FOREACH(entity, var, vars)
            sb_cat(sa, count++? " ": "", entity_dot_name(var));
          sb_cat(sa, "\"");
        }
        sb_cat(sa, "];\n");
 
        some_arcs = true;
      }
      gen_free_list(vars), vars = NIL;
    }
 
    bool some_image_stuff = !dagvtx_other_stuff_p(vtx);
 
    if (!filter_nodes || some_image_stuff || (filter_nodes && some_arcs))
    {
      // appends the node description
      dagvtx_dot_node(out, "  ", vtx);
      fprintf(out, " [%s", attribute);
      if (!label_nodes)
        // show a short label with only the operation
        fprintf(out, ",label=\"%s\"", dagvtx_compact_operation(vtx));
      fprintf(out, "];\n");
      // now appends arcs...
      string_buffer_to_file(sa, out);
    }
 
    // cleanup
    string_buffer_free(&sa);
  }
}

References count, dag_vertices, dagvtx_compact_operation(), dagvtx_content, dagvtx_dot_node(), dagvtx_dot_node_sb(), dagvtx_number(), dagvtx_other_stuff_p(), dagvtx_statement(), dagvtx_succs, entity_dot_name(), entity_undefined, FOREACH, fprintf(), freia_scalar_rw_dep(), gen_free_list(), get_bool_property(), NIL, out, sb_cat, SCL_DEP, string_buffer_free(), string_buffer_make(), string_buffer_to_file(), vtxcontent_optype, vtxcontent_out, and what_operation_shape().

Referenced by dag_dot().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_dot_node()

static void dagvtx_dot_node ( FILE *  out, const string  prefix, const dagvtx  v  )

static

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

{
  fprintf(out, "%s\"%"_intFMT" %s\"", prefix? prefix: "",
          dagvtx_number(v), dagvtx_compact_operation(v));
}

References _intFMT, dagvtx_compact_operation(), dagvtx_number(), fprintf(), out, and prefix.

Referenced by dag_dot(), and dagvtx_dot().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_dot_node_sb()

static void dagvtx_dot_node_sb ( string_buffer  sb, const string  prefix, const dagvtx  v  )

static

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

{
  sb_cat(sb, prefix? prefix: "");
  sb_cat(sb, "\"", i2a((int) dagvtx_number(v)),
         " ", dagvtx_compact_operation(v),  "\"");
}

References dagvtx_compact_operation(), dagvtx_number(), i2a(), prefix, and sb_cat.

Referenced by dagvtx_dot().

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	name,
		const dagvtx	v
	)

for dag debug.

Parameters

out	ut
name	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

v

)

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

v

)

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

static bool dagvtx_is_copy_p ( const dagvtx  v )

static

returns whether the vertex is an image copy operation.

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

{
  return dagvtx_is_operator_p(v, "copy");
}

References dagvtx_is_operator_p().

Referenced by all_vertices_are_copies_or_measures_p(), dag_dot(), freia_dag_optimize(), and number_of_copies().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_is_measurement_p()

bool dagvtx_is_measurement_p

(

const dagvtx

v

)

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

static bool dagvtx_is_operator_p ( const dagvtx  v, const string  opname  )

static

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

{
  vtxcontent c = dagvtx_content(v);
  const freia_api_t * api = get_freia_api(vtxcontent_opid(c));
  return same_string_p(cat(AIPO, opname), api->function_name);
}

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

Referenced by dag_simplify(), and dagvtx_is_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_list_dot()

static void dagvtx_list_dot ( FILE *  out, const string  comment, const list  l, const set  used  )

static

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

{
  if (comment) fprintf(out, "  // %s\n", comment);
  FOREACH(dagvtx, v, l)
  {
    entity img = vtxcontent_out(dagvtx_content(v));
    fprintf(out, "  \"%s%s\" [shape=circle];\n",
            entity_dot_name(img),
            used? (set_belong_p(used, img)? "'": ""): "");
  }
  fprintf(out, "\n");
}

References comment(), dagvtx_content, entity_dot_name(), FOREACH, fprintf(), out, set_belong_p(), and vtxcontent_out.

Referenced by dag_dot().

Here is the call graph for this function:

Here is the caller graph for this function:

dagvtx_nb()

static string dagvtx_nb ( const void *  s )

static

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

                                        {
  return i2a((int) dagvtx_number((dagvtx) s));
}

References dagvtx_number(), and i2a().

Referenced by dag_connected_component(), and dag_split_connected_components().

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	what,
		const list	l
	)

Parameters

out	ut
what	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

v

)

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

v

)

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

v

)

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

v

)

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

v

)

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

v

)

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

v

)

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:

do_point_to()

static expression do_point_to ( entity  var, string  field_name  )

static

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

{
  // entity f2d = local_name_to_top_level_entity(FREIA_IMAGE_TYPE);
  expression evar = entity_to_expression(var);
  return call_to_expression(make_call(
    local_name_to_top_level_entity(POINT_TO_OPERATOR_NAME),
    gen_make_list(expression_domain, evar,
                  entity_to_expression(freia_data2d_field(field_name)),
                  NULL)));
}

References call_to_expression(), entity_to_expression(), expression_domain, freia_data2d_field(), gen_make_list(), local_name_to_top_level_entity(), make_call(), and POINT_TO_OPERATOR_NAME.

Referenced by new_local_image_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_dot_name()

static const char* entity_dot_name ( entity  e )

static

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

{
  return entity_user_name(e);
}

References entity_user_name().

Referenced by dag_dot(), dagvtx_copy_list_dot(), dagvtx_dot(), and dagvtx_list_dot().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_list_dump()

static void entity_list_dump ( FILE *  out, const string  what, const list  l  )

static

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

{
  fprintf(out, "%s: ", what);
  FOREACH(entity, e, l)
    fprintf(out, " %s,", safe_entity_name(e));
  fprintf(out, "\n");
}

References FOREACH, fprintf(), out, and safe_entity_name().

Referenced by dagvtx_dump().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_fist_item()

static entity extract_fist_item ( list *  lp )

static

extract first entity item from list.

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

{
  list l = gen_list_head(lp, 1);
  entity e = ENTITY(CAR(l));
  gen_free_list(l);
  return e;
}

References CAR, ENTITY, gen_free_list(), and gen_list_head().

Referenced by dag_append_freia_call().

Here is the call graph for this function:

Here is the caller graph for this function:

find_twin_vertex()

static dagvtx find_twin_vertex ( dag  d, dagvtx  target  )

static

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

{
  // pips_debug(9, "target is %"_intFMT"\n", dagvtx_number(target));
  FOREACH(dagvtx, v, dag_vertices(d))
    if (dagvtx_number(target)==dagvtx_number(v))
      return v;
  pips_internal_error("twin vertex not found for %" _intFMT "\n",
                      dagvtx_number(target));
  return NULL;
}

References _intFMT, dag_vertices, dagvtx_number(), FOREACH, and pips_internal_error.

Referenced by freia_hack_fix_global_ins_outs().

Here is the call graph for this function:

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

static entity freia_data2d_field ( string  field )

static

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

{
  string cu =
    compilation_unit_of_module(entity_local_name(get_current_module_entity()));
  entity fi = FindOrCreateEntity(cu, TYPEDEF_PREFIX FREIA_IMAGE_TYPE);
  pips_assert("freia_data2d type found", fi!=entity_undefined);
  type ut = ultimate_type(entity_type(fi));
 
  list fields =
    type_struct(entity_type(basic_derived(variable_basic(type_variable(ut)))));
  pips_assert("some fields", fields);
  FOREACH(entity, f, fields)
    if (same_string_p(field,
                      entity_local_name(f)+strlen(DUMMY_STRUCT_PREFIX)+2))
      return f;
  // should not get there
  pips_internal_error("cannot find freia_data2d field %s\n", field);
  return NULL;
}

References basic_derived, compilation_unit_of_module(), DUMMY_STRUCT_PREFIX, entity_local_name(), entity_type, entity_undefined, f(), FindOrCreateEntity(), FOREACH, FREIA_IMAGE_TYPE, get_current_module_entity(), pips_assert, pips_internal_error, same_string_p, type_struct, type_variable, TYPEDEF_PREFIX, ultimate_type(), and variable_basic.

Referenced by do_point_to().

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_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_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:

fs_expression_list_to_entity_list()

static list fs_expression_list_to_entity_list ( list  args, int  nargs  )

static

convert the first n items in list args to entities.

of entity

Parameters

args	of expression

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

{
  list /* of entity */ lent = NIL;
  int n=0;
  FOREACH(expression, ex, args)
  {
    syntax s = expression_syntax(ex);
    pips_assert("is a ref", syntax_reference_p(s));
    reference r = syntax_reference(s);
    pips_assert("simple ref", reference_indices(r)==NIL);
    lent = CONS(entity, reference_variable(r), lent);
    if (++n==nargs) break;
  }
  lent = gen_nreverse(lent);
  return lent;
}

References CONS, expression_syntax, FOREACH, gen_nreverse(), NIL, pips_assert, reference_indices, reference_variable, syntax_reference, and syntax_reference_p.

Referenced by dag_append_freia_call().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_list_equals_p()

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

static

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

{
  bool equal = true;
  list p1 = (list) l1, p2 = (list) l2;
  while (equal && p1 && p2) {
    if (CHUNK(CAR(p1))!=CHUNK(CAR(p2)))
      equal = false;
    p1 = CDR(p1), p2 = CDR(p2);
  }
  equal &= (!p1 && !p2);
  return equal;
}

References CAR, CDR, and CHUNK.

Referenced by freia_dag_optimize().

Here is the caller graph for this function:

get_upper_model()

static entity get_upper_model ( entity  model, const hash_table  occs  )

static

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

{
  entity image = NULL;
  // first look in declarations
  gen_context_recurse(entity_initial(model), &image,
                      reference_domain, image_ref_flt, gen_null2);
  // then look for statements...
  if (!image && hash_defined_p(occs, model))
  {
    SET_FOREACH(statement, s, (set) hash_get(occs, model))
    {
      if (is_freia_alloc(s))
        gen_context_recurse(freia_statement_to_call(s), &image,
                            reference_domain, image_ref_flt, gen_null2);
      if (image && image!=model) break;
      image = NULL;
    }
  }
  // go upwards!
  if (image && image!=model) image = get_upper_model(image, occs);
  return image? image: model;
}

References entity_initial, freia_statement_to_call(), gen_context_recurse, gen_null2(), hash_defined_p(), hash_get(), image_ref_flt(), is_freia_alloc(), reference_domain, and SET_FOREACH.

Referenced by new_local_image_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

image_ref_flt()

static bool image_ref_flt ( reference  r, entity *  image  )

static

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

{
  entity var = reference_variable(r);
  if (freia_image_variable_p(var))
  {
    *image = var;
    gen_recurse_stop(NULL);
  }
  // do not go in array indexes
  return false;
}

References freia_image_variable_p(), gen_recurse_stop(), and reference_variable.

Referenced by freia_memory_management_statement(), and get_upper_model().

Here is the call graph for this function:

Here is the caller graph for this function:

list_commuted_p()

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

static

Returns

whether two lists are commuted

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

{
  pips_assert("length 2", gen_length(l1)==2 && gen_length(l2)==2);
  return CHUNKP(CAR(CDR(l1)))==CHUNKP(CAR(l2)) &&
    CHUNKP(CAR(l1))==CHUNKP(CAR(CDR(l2)));
}

References CAR, CDR, CHUNKP, gen_length(), and pips_assert.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

new_local_image_variable()

static entity new_local_image_variable ( entity  model, const hash_table  occs  )

static

Returns

a new image from the model

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

{
  entity img = NULL;
  int index = 1;
  do
  {
    string varname;
    int n = asprintf(&varname, "%s_%d", entity_local_name(model), index);
    pips_assert("asprintf succeeded", n!=-1);
    img = clone_variable_with_new_name
      (model, varname, module_local_name(get_current_module_entity()));
    free(varname);
    index++;
    if (img)
    {
      // use the reference of the model instead of the model itself, if found.
      entity ref = get_upper_model(model, occs);
 
      call alloc = make_call(local_name_to_top_level_entity(FREIA_ALLOC),
                             gen_make_list(expression_domain,
                                           do_point_to(ref, "bpp"),
                                           do_point_to(ref, "widthWa"),
                                           do_point_to(ref, "heightWa"),
                                           NULL));
 
      // handle allocation as the declaration initial value, if possible
      if (formal_parameter_p(ref))
      {
        free_value(entity_initial(img));
        entity_initial(img) = make_value_expression(call_to_expression(alloc));
      }
      else
      {
        statement sa = freia_memory_management_statement(ref, occs, true);
 
        if (sa)
        {
          // insert statement just after the reference declaration
          free_value(entity_initial(img));
          entity_initial(img) = make_value_expression(int_to_expression(0));
 
          statement na = make_assign_statement(entity_to_expression(img),
                                               call_to_expression(alloc));
          insert_statement(sa, na, false);
        }
        else
        {
          // this may happen if the "ref" is allocated at its declaration point,
          // as this statement is not currently found by our search
 
          // ??? try with a direct declaration
          free_value(entity_initial(img));
          entity_initial(img) =
            make_value_expression(call_to_expression(alloc));
        }
      }
 
      // should not be a parameter! overwrite storage if so...
      if (formal_parameter_p(img))
      {
        free_storage(entity_storage(img));
        entity_storage(img) = make_storage_rom();
        // make_storage_ram(make_ram(get_current_module_entity(),
        // entity_undefined, UNKNOWN_RAM_OFFSET, NIL));
      }
    }
  }
  while (img==NULL);
  return img;
}

References alloc(), asprintf, call_to_expression(), clone_variable_with_new_name(), do_point_to(), entity_initial, entity_local_name(), entity_storage, entity_to_expression(), expression_domain, formal_parameter_p(), free(), free_storage(), free_value(), FREIA_ALLOC, freia_memory_management_statement(), gen_make_list(), get_current_module_entity(), get_upper_model(), insert_statement(), int_to_expression(), local_name_to_top_level_entity(), make_assign_statement(), make_call(), make_storage_rom(), make_value_expression(), module_local_name(), pips_assert, and ref.

Referenced by dag_fix_image_reuse().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_copies()

static int number_of_copies ( list  l )

static

Returns

the number of copies in the vertex list

Parameters

l

of dagvtx

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

{
  int n=0;
  FOREACH(dagvtx, v, l)
    if (dagvtx_is_copy_p(v))
      n++;
  return n;
}

References dagvtx_is_copy_p(), and FOREACH.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

other_significant_uses()

static bool other_significant_uses ( entity  e, const hash_table  occs, const set  stats  )

static

Returns

whether there is a significant use of e outside of stats

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

{
  if (!occs) return true; // safe
  set all_stats = (set) hash_get(occs, e);
  pips_assert("some statement set", all_stats);
  set others = set_make(set_pointer);
  set_difference(others, all_stats, stats);
  // is there something significant in others?
  bool used = any_use_statement(others);
  set_free(others);
  pips_debug(9, "%s is %susefull\n", entity_name(e), used? "": "not ");
  return used;
}

References any_use_statement(), entity_name, hash_get(), pips_assert, pips_debug, set_difference(), set_free(), set_make(), and set_pointer.

Referenced by dag_compute_outputs().

Here is the call graph for this function:

Here is the caller graph for this function:

propagate_constant_image()

static bool propagate_constant_image ( dagvtx  v, entity  image, expression  val  )

static

recursively propagate a constant image on a vertex

Parameters

v	starting vertex
image	which is constant
val	actual value of all image pixels

Returns

whether v can be unlinked ??? small memory leaks

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

{
  vtxcontent c = dagvtx_content(v);
  _int op = vtxcontent_opid(c);
  expression newval = expression_undefined;
  if (op<=0) return false;
  // op>0
  const freia_api_t * api = get_freia_api(op);
  int noccs = gen_occurences(image, vtxcontent_inputs(c));
  pips_assert("image is used at least once", noccs>0);
  int nargs = gen_length(vtxcontent_inputs(c));
  bool image_is_first = ENTITY(CAR(vtxcontent_inputs(c)))==image;
 
  if (copy_image_p(v)!=NULL)
  {
    propagate_constant_image_to_succs(v, val);
    set_aipo_copy(v, image);
    return false;
  }
 
  if (noccs==1 && nargs==1) // Cst(n)<op>.m => Cst(n<op>m)
  {
    string op = NULL;
    if (aipo_op_p(api, "add_const"))      op = "+";
    else if (aipo_op_p(api, "sub_const")) op = "-";
    else if (aipo_op_p(api, "mul_const")) op = "*";
    else if (aipo_op_p(api, "div_const")) op = "/";
    else if (aipo_op_p(api, "and_const")) op = BITWISE_AND_OPERATOR_NAME;
    else if (aipo_op_p(api, "or_const"))  op = "|";
    else if (aipo_op_p(api, "xor_const")) op = BITWISE_XOR_OPERATOR_NAME;
    // ??? TODO addsat, subsat, inf, sup, not, log2...
    // but I need the corresponding scalar functions
    // some of which depends on the actual pixel type
    else if (aipo_op_p(api, "erode_6c") || aipo_op_p(api, "dilate_6c") ||
             aipo_op_p(api, "erode_8c") || aipo_op_p(api, "dilate_8c"))
      newval = val;
    // ??? TODO threshold
    // ??? TODO global_min/global_max can be switch to a simple assign
    // ??? TODO global_vol can be switched to n_pixels*val
 
    if (op)
      newval = compute_constant(op, val, freia_get_nth_scalar_param(v, 1));
    if (newval!=expression_undefined)
    {
      set_aipo_constant(v, newval);
      return true;
    }
  }
  else if (noccs==1 && nargs==2)
  {
    string op = NULL;
    entity other = image_is_first?
      ENTITY(CAR(CDR(vtxcontent_inputs(c)))): ENTITY(CAR(vtxcontent_inputs(c)));
 
    if (aipo_op_p(api, "add"))      op = "add_const";
    else if (aipo_op_p(api, "mul")) op = "mul_const";
    else if (aipo_op_p(api, "and")) op = "add_const";
    else if (aipo_op_p(api, "or"))  op = "or_const";
    else if (aipo_op_p(api, "xor")) op = "xor_const";
    else if (aipo_op_p(api, "inf")) op = "inf_const";
    else if (aipo_op_p(api, "sup")) op = "sup_const";
    else if (aipo_op_p(api, "addsat")) op = "addsat_const";
    else if (aipo_op_p(api, "subsat")) op = "subsat_const";
    else if (aipo_op_p(api, "absdiff")) op = "absdiff_const";
    else if (aipo_op_p(api, "sub"))
      op = image_is_first? "const_sub": "sub_const";
    else if (aipo_op_p(api, "div"))
      op = image_is_first? "const_div": "div_const";
 
    if (op)
    {
      set_aipo_call(v, op, other, val);
      return true;
    }
  }
  else if (noccs==2)
  {
    // special case for (image <op> image)
    if (aipo_op_p(api, "add"))
    {
      set_aipo_constant(v, compute_constant("*", val, int_to_expression(2)));
      return true;
    }
    else if (aipo_op_p(api, "sub"))
    {
      set_aipo_constant(v, int_to_expression(0));
      return true;
    }
  }
  return false;
}

References aipo_op_p, BITWISE_AND_OPERATOR_NAME, BITWISE_XOR_OPERATOR_NAME, CAR, CDR, compute_constant(), copy_image_p(), dagvtx_content, ENTITY, expression_undefined, freia_get_nth_scalar_param(), gen_length(), gen_occurences(), get_freia_api(), int_to_expression(), pips_assert, propagate_constant_image_to_succs(), set_aipo_call(), set_aipo_constant(), set_aipo_copy(), vtxcontent_inputs, and vtxcontent_opid.

Referenced by propagate_constant_image_to_succs().

Here is the call graph for this function:

Here is the caller graph for this function:

propagate_constant_image_to_succs()

static void propagate_constant_image_to_succs ( dagvtx  v, expression  val  )

static

propagate constant image to vertex successors

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

{
  vtxcontent c = dagvtx_content(v);
  list nsuccs = NIL;
  // i=? -> i+i => to identical successors, but forward once
  set seen = set_make(set_pointer);
  FOREACH(dagvtx, s, dagvtx_succs(v))
  {
    if (!set_belong_p(seen, s) &&
        !propagate_constant_image(s, vtxcontent_out(c), val))
      nsuccs = CONS(dagvtx, s, nsuccs);
    set_add_element(seen, seen, s);
  }
  set_free(seen);
  dagvtx_succs(v) = gen_nreverse(nsuccs);
}

References CONS, dagvtx_content, dagvtx_succs, FOREACH, gen_nreverse(), NIL, propagate_constant_image(), seen, set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, and vtxcontent_out.

Referenced by propagate_constant_image(), and set_aipo_constant().

Here is the call graph for this function:

Here is the caller graph for this function:

same_operation_p()

static bool same_operation_p ( const dagvtx  v1, const dagvtx  v2  )

static

Returns

whether two vertices are the same operation

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

{
  return
    dagvtx_optype(v1) == dagvtx_optype(v2) &&
    dagvtx_opid(v1) == dagvtx_opid(v2);
}

References dagvtx_opid(), and dagvtx_optype().

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

set_aipo_call()

static void set_aipo_call ( dagvtx  v, string  name, entity  img, expression  val  )

static

switch vertex statement to an aipo call

Parameters

v	vertex to modify
name	function short name to switch to, must be an AIPO function
img	possible image argument, may be entity_undefined or NULL
val	possible scalar argument, may be expression undefined or NULL

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

{
  vtxcontent c = dagvtx_content(v);
  pstatement ps = vtxcontent_source(c);
  pips_assert("some statement!", pstatement_statement_p(ps));
 
  // build function name
  string fname = strdup(cat(AIPO, name));
 
  // remove previous image inputs
  gen_free_list(vtxcontent_inputs(c));
  vtxcontent_inputs(c) =
    (img && img!=entity_undefined)? CONS(entity, img, NIL): NIL;
 
  // set id & type
  vtxcontent_opid(c) = hwac_freia_api_index(fname);
  pips_assert("function index found", vtxcontent_opid(c)!=-1);
  vtxcontent_optype(c) =
    same_string_p(name, "copy")? spoc_type_nop: spoc_type_alu;
 
  // set call
  call cf = freia_statement_to_call(pstatement_statement(ps));
  entity func = local_name_to_top_level_entity(fname);
  pips_assert("AIPO function found", func!=entity_undefined);
  call_function(cf) = func;
 
  // build expression list in reverse order
  list args = NIL;
  if (val && val!=expression_undefined)
    args = CONS(expression, copy_expression(val), args);
  if (img && img!=entity_undefined)
    args = CONS(expression, entity_to_expression(img), args);
  args = CONS(expression, entity_to_expression(vtxcontent_out(c)), args);
  // with a bold memory leak (effects may use refs?)
  call_arguments(cf) = args;
 
  // cleanup
  free(fname);
}

References AIPO, call_arguments, call_function, cat, CONS, copy_expression(), dagvtx_content, entity_to_expression(), entity_undefined, expression_undefined, free(), freia_statement_to_call(), gen_free_list(), hwac_freia_api_index(), local_name_to_top_level_entity(), NIL, pips_assert, pstatement_statement, pstatement_statement_p, same_string_p, spoc_type_alu, spoc_type_nop, strdup(), vtxcontent_inputs, vtxcontent_opid, vtxcontent_optype, vtxcontent_out, and vtxcontent_source.

Referenced by dag_simplify(), propagate_constant_image(), set_aipo_constant(), and set_aipo_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

set_aipo_constant()

static void set_aipo_constant ( dagvtx  v, expression  val  )

static

set vertex as a constant image and propagate to successors

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

{
  set_aipo_call(v, "set_constant", entity_undefined, val);
  propagate_constant_image_to_succs(v, val);
}

References entity_undefined, propagate_constant_image_to_succs(), and set_aipo_call().

Referenced by dag_simplify(), and propagate_constant_image().

Here is the call graph for this function:

Here is the caller graph for this function:

set_aipo_copy()

static void set_aipo_copy ( dagvtx  v, entity  e  )

static

switch vertex to a copy of an image

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

{
  set_aipo_call(v, "copy", e, NULL);
}

References set_aipo_call().

Referenced by dag_simplify(), and propagate_constant_image().

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:

substitute_image_in_statement()

static void substitute_image_in_statement ( dagvtx  v, entity  source, entity  target, bool  used  )

static

subtitute produced or used image in the statement of vertex v.

Parameters

v	vertex
source	image variable to replace
target	new image variable to use
used	whether to replace used image (input, forward propagation) or procuded image (output, backward propagation)

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

{
  pips_debug(8, "image %s -> %s in %"_intFMT"\n",
             entity_name(source), entity_name(target), dagvtx_number(v));
 
  int nsubs=0;
  vtxcontent vc = dagvtx_content(v);
  pstatement ps = vtxcontent_source(vc);
  pips_assert("is a statement", pstatement_statement_p(ps));
 
  // get call
  call c = freia_statement_to_call(pstatement_statement(ps));
  list args = call_arguments(c);
 
  const freia_api_t * api = dagvtx_freia_api(v);
 
  // how many argument to skip, how many to replace
  unsigned int skip, subs;
 
  if (used)
    skip = api->arg_img_out, subs = api->arg_img_in;
  else
    skip = 0, subs = api->arg_img_out;
 
  pips_assert("call length is okay", gen_length(args)>=skip+subs);
 
  while (skip--)
    args = CDR(args);
 
  while (subs--)
  {
    expression e = EXPRESSION(CAR(args));
    // I'm not sure what to do if an image is not a simple reference...
    pips_assert("image argument is a reference", expression_reference_p(e));
    reference r = expression_reference(e);
 
    if (reference_variable(r)==source)
      nsubs++, reference_variable(r) = target;
    args = CDR(args);
  }
 
  // ??? Hmmm... this happens in freia_3muls, not sure why.
  // pips_assert("some image substitutions", nsubs>0);
}

References _intFMT, freia_api_t::arg_img_in, freia_api_t::arg_img_out, call_arguments, CAR, CDR, dagvtx_content, dagvtx_freia_api, dagvtx_number(), entity_name, EXPRESSION, expression_reference(), expression_reference_p(), freia_statement_to_call(), gen_length(), pips_assert, pips_debug, pstatement_statement, pstatement_statement_p, reference_variable, and vtxcontent_source.

Referenced by freia_dag_optimize(), switch_vertex_to_a_copy(), and unlink_copy_vertex().

Here is the call graph for this function:

Here is the caller graph for this function:

swis_call_flt()

static bool swis_call_flt ( call  c, swis_ctx *  ctx  )

static

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

{
  const freia_api_t * api = hwac_freia_api(entity_local_name(call_function(c)));
  if (api)
  {
    list args = call_arguments(c);
    pips_assert("freia api call length is ok",
                gen_length(args)== (api->arg_img_out + api->arg_img_in +
                                    api->arg_misc_out + api->arg_misc_in));
    unsigned int i;
    // output arguments
    for(i=0; i<api->arg_img_out; i++)
    {
      if (!ctx->write)
        gen_recurse_stop(EXPRESSION(CAR(args)));
      args = CDR(args);
    }
    // input arguments
    for(i=0; i<api->arg_img_in; i++)
    {
      if (ctx->write)
        gen_recurse_stop(EXPRESSION(CAR(args)));
      args = CDR(args);
    }
    // skip remainder anyway
    while (args)
    {
      gen_recurse_stop(EXPRESSION(CAR(args)));
      args = CDR(args);
    }
  }
  // else this is not an AIPO call... we substitute everywhere
  return true;
}

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, call_arguments, call_function, CAR, CDR, entity_local_name(), EXPRESSION, gen_length(), gen_recurse_stop(), hwac_freia_api(), pips_assert, and swis_ctx::write.

Referenced by freia_switch_image_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

swis_ref_rwt()

static void swis_ref_rwt ( reference  r, swis_ctx *  ctx  )

static

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

{
  if (reference_variable(r)==ctx->old)
    reference_variable(r) = ctx->new;
}

References swis_ctx::new, swis_ctx::old, and reference_variable.

Referenced by freia_switch_image_in_statement().

Here is the caller graph for this function:

switch_image_variable()

static void switch_image_variable ( dagvtx  v, entity  old, entity  img  )

static

switch to new image variable in v & its direct successors

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

{
  vtxcontent c = dagvtx_content(v);
  pips_assert("switch image output", vtxcontent_out(c)==old);
  vtxcontent_out(c) = img;
  statement st = dagvtx_statement(v);
  pips_assert("some production statement", st!=NULL);
  freia_switch_image_in_statement(st, old, img, true);
  FOREACH(dagvtx, s, dagvtx_succs(v))
  {
    vtxcontent cs = dagvtx_content(s);
    gen_replace_in_list(vtxcontent_inputs(cs), old, img);
    statement st = dagvtx_statement(s);
    pips_assert("some producer statement", st!=NULL);
    freia_switch_image_in_statement(st, old, img, false);
  }
}

References dagvtx_content, dagvtx_statement(), dagvtx_succs, FOREACH, freia_switch_image_in_statement(), gen_replace_in_list(), pips_assert, vtxcontent_inputs, and vtxcontent_out.

Referenced by dag_fix_image_reuse().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_vertex_to_a_copy()

static void switch_vertex_to_a_copy ( dagvtx  target, dagvtx  source, list  tpreds  )

static

replace target vertex by a copy of source results...

Parameters

target	to be removed
source	does perform the same computation
tpreds	target predecessors to be added to source

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

{
  pips_debug(5, "replacing %"_intFMT" by %"_intFMT"\n",
             dagvtx_number(target), dagvtx_number(source));
 
  ifdebug(9) {
    dagvtx_dump(stderr, "in source", source);
    dagvtx_dump(stderr, "in target", target);
  }
 
  entity src_img = dagvtx_image(source);
  // fix contents
  vtxcontent cot = dagvtx_content(target);
  vtxcontent_optype(cot) = spoc_type_nop;
  vtxcontent_opid(cot) = hwac_freia_api_index(AIPO "copy");
  gen_free_list(vtxcontent_inputs(cot));
  vtxcontent_inputs(cot) = CONS(entity, src_img, NIL);
 
  // fix vertices
  FOREACH(dagvtx, v, tpreds)
    gen_remove(&dagvtx_succs(v), target);
 
  entity trg_img = dagvtx_image(target);
  FOREACH(dagvtx, s, dagvtx_succs(target))
  {
    gen_list_patch(vtxcontent_inputs(dagvtx_content(s)), trg_img, src_img);
    // also fix subsequent statements, for AIPO output
    substitute_image_in_statement(s, trg_img, src_img, true);
  }
  dagvtx_succs(source) = gen_once(target, dagvtx_succs(source));
  dagvtx_succs(source) = gen_nconc(dagvtx_succs(target), dagvtx_succs(source));
  dagvtx_succs(target) = NIL;
 
  // should I kill the statement? no, done by the copy removal stuff
 
  ifdebug(9) {
    dagvtx_dump(stderr, "out source", source);
    dagvtx_dump(stderr, "out target", target);
  }
}

References _intFMT, AIPO, CONS, dagvtx_content, dagvtx_dump(), dagvtx_image(), dagvtx_number(), dagvtx_succs, FOREACH, gen_free_list(), gen_list_patch(), gen_nconc(), gen_once(), gen_remove(), hwac_freia_api_index(), ifdebug, NIL, pips_debug, spoc_type_nop, substitute_image_in_statement(), vtxcontent_inputs, vtxcontent_opid, and vtxcontent_optype.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_vertex_to_assign()

static bool switch_vertex_to_assign ( dagvtx  target, dagvtx  source  )

static

replace target measure to a copy of source result...

Parameters

target	to be removed/replaced because redundant
source	to be kept

Returns

whether the statement is to be actually removed

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

{
  pips_debug(5, "replacing measure %"_intFMT" by %"_intFMT" result\n",
             dagvtx_number(target), dagvtx_number(source));
 
  // update target vertex
  vtxcontent cot = dagvtx_content(target);
  vtxcontent_optype(cot) = spoc_type_oth;
  vtxcontent_opid(cot) = hwac_freia_api_index("freia_aipo_scalar_copy");
  // no more image inputs
  gen_free_list(vtxcontent_inputs(cot));
  vtxcontent_inputs(cot) = NIL;
 
  // ??? source -> target scalar dependency?
 
  // update actual statement.
  call cref = statement_call(dagvtx_statement(source));
  expression eref = EXPRESSION(CAR(CDR(call_arguments(cref))));
  call cnew = statement_call(dagvtx_statement(target));
  expression enew = EXPRESSION(CAR(CDR(call_arguments(cnew))));
 
  if (expression_equal_p(eref, enew))
    // just remove the fully redundant measure
    return true;
 
  // replace by assign
  call_function(cnew) = local_name_to_top_level_entity("=");
 
  // ??? memory leak or core dump
  // gen_full_free_list(call_arguments(cnew));
  // possibly due to effects which are loaded?
  call_arguments(cnew) =
    gen_make_list(expression_domain,
                  dereference_expression(enew),
                  dereference_expression(eref),
                  NIL);
 
  return false;
}

References _intFMT, call_arguments, call_function, CAR, CDR, dagvtx_content, dagvtx_number(), dagvtx_statement(), dereference_expression(), EXPRESSION, expression_domain, expression_equal_p(), gen_free_list(), gen_make_list(), hwac_freia_api_index(), local_name_to_top_level_entity(), NIL, pips_debug, spoc_type_oth, statement_call(), vtxcontent_inputs, vtxcontent_opid, and vtxcontent_optype.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

unlink_copy_vertex()

static void unlink_copy_vertex ( dag  d, const entity  source, dagvtx  copy  )

static

"copy" copies "source" image in dag "d".

remove it properly (forward copy propagation)

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

{
  pips_debug(8, "unlinking %"_intFMT"\n", dagvtx_number(copy));
 
  entity target = vtxcontent_out(dagvtx_content(copy));
  // may be NULL if source is an input
  dagvtx prod = dagvtx_get_producer(d, copy, source, 0);
 
  // add copy successors as successors of prod
  // it is kept as a successor in case it is not removed
  if (prod)
  {
    FOREACH(dagvtx, vs, dagvtx_succs(copy))
      dagvtx_succs(prod) = gen_once(vs, dagvtx_succs(prod));
  }
 
  // replace use of target image by source image in all v successors
  FOREACH(dagvtx, succ, dagvtx_succs(copy))
  {
    vtxcontent sc = dagvtx_content(succ);
    gen_list_patch(vtxcontent_inputs(sc), target, source);
 
    // also in the statement inputs... (needed for AIPO target)
    substitute_image_in_statement(succ, target, source, true);
  }
 
  // copy has no more successors
  gen_free_list(dagvtx_succs(copy));
  dagvtx_succs(copy) = NIL;
}

References _intFMT, dagvtx_content, dagvtx_get_producer(), dagvtx_number(), dagvtx_succs, FOREACH, gen_free_list(), gen_list_patch(), gen_once(), NIL, pips_debug, substitute_image_in_statement(), vtxcontent_inputs, and vtxcontent_out.

Referenced by freia_dag_optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_used_as_later_input()

static bool variable_used_as_later_input ( entity  img, list  ld  )

static

hmmm...

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

{
  bool used = false;
  FOREACH(dag, d, ld)
  {
    FOREACH(dagvtx, v, dag_inputs(d))
    {
      if (dagvtx_image(v)==img)
      {
        used = true;
        break;
      }
    }
    if (used) break;
  }
  pips_debug(8, "%s: %s\n", entity_name(img), bool_to_string(used));
  return used;
}

References bool_to_string(), dag_inputs, dagvtx_image(), entity_name, FOREACH, and pips_debug.

Referenced by dag_compute_outputs().

Here is the call graph for this function:

Here is the caller graph for this function:

vertex_list_sorted_by_entities()

static void vertex_list_sorted_by_entities ( list  l )

static

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

{
  gen_sort_list(l, (gen_cmp_func_t) dagvtx_cmp_entity);
}

References dagvtx_cmp_entity(), and gen_sort_list().

Referenced by dag_append_vertex(), and dag_remove_vertex().

Here is the call graph for this function:

Here is the caller graph for this function: