#include <stdint.h>
#include <stdlib.h>
#include <ctype.h>
#include "genC.h"
#include "misc.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "properties.h"
#include "freia.h"
#include "hwac.h"
#include "freia_sigmac.h"

Include dependency graph for freia_sigmac.c:

Macros
#define	SIGMAC_INSTANTIATE(a, b) " agent " a " = new " b ";\n"

#define	SIGMAC_CONNECT(a, b) " connect (" a ", " b ");\n"

#define	REPLICATION_AGENT "rep"

#define	SIGMAC_HELPER "freia_mppa_launch"

#define	N_PREDEFINED_CONTROLLERS 5

#define	MAIN_PATH "cd .. && ./main"

Functions
static void	sigmac_name_instances (dag dg, hash_table htid)
	Populates the hash table htid: one dagvtx is linked to an unique id depending on its freia_api_t. More...

static string	sc_vtx_tostring (const dagvtx v, const hash_table htid)
	Generate a unique string per dagvtx consisting in. More...

static bool	is_param_dynamic (expression arg)
	Determine if an argument contains references to other variables (dirty hack based on isalpha) More...

static bool	has_vtx_dynamic_params (dagvtx v)
	Determine if a dagvtx has at least one dynamic parameter. More...

static list	sc_get_params_values (dagvtx vtx, hash_table hparams, int *nparams)
	Returns a list of values of one dagvtx misc input parameters. More...

static bool	sc_print_kernel (string_buffer sb_par, dagvtx v)
	Print the value of a morphological kernel extracted from a dagvtx. More...

static bool	sc_kernel_compute_loop (string_buffer sb_morpho, const dagvtx vtx, string kname)
	Print a kernel customized inner loop from a morphological kernel. More...

static void	sc_kernel_specific_agent (string_buffer sb_morpho, hash_table hparams, const dag dg)

static void	sigmac_params_decl (string_buffer sb_par, dag dg, hash_table hparams, int *pnparams)
	Generates the constant parameters declaration. More...

static void	sc_inst (string_buffer sb, const dagvtx v, const hash_table htid, const hash_table hparams, string miscparams, bool is_dynamic)
	Generate the instanciation of an agent in the forme "agent instname = new agentname (parameters)". More...

static int	sc_get_port_id (dagvtx current_vtx, dagvtx succ, dag dg)
	Helper function determine the input port of the succ dagvtx to be connected to the output port of current_vtx dagvtx succ must be in dagvtx_succs(current_vtx) More...

static void	sc_delimiter (string_buffer sb, const string title)
	Generate a 3 lines commented code delimiter with a centered title. More...

Variables
static int	n_dags = 0

Macro Definition Documentation

◆ MAIN_PATH

#define MAIN_PATH "cd .. && ./main"

◆ N_PREDEFINED_CONTROLLERS

#define N_PREDEFINED_CONTROLLERS 5

◆ REPLICATION_AGENT

#define REPLICATION_AGENT "rep"

Definition at line 53 of file freia_sigmac.c.

◆ SIGMAC_CONNECT

#define SIGMAC_CONNECT	(	a,
		b
	)	" connect (" a ", " b ");\n"

Definition at line 52 of file freia_sigmac.c.

◆ SIGMAC_HELPER

#define SIGMAC_HELPER "freia_mppa_launch"

◆ SIGMAC_INSTANTIATE

#define SIGMAC_INSTANTIATE	(	a,
		b
	)	" agent " a " = new " b ";\n"

Definition at line 51 of file freia_sigmac.c.

Function Documentation

◆ has_vtx_dynamic_params()

static bool has_vtx_dynamic_params ( dagvtx v )

static

Determine if a dagvtx has at least one dynamic parameter.

Definition at line 113 of file freia_sigmac.c.

                                              {
   const freia_api_t *f = get_freia_api_vtx(v);
   if (!f)
     return false;
   if (strstr(f->function_name, "_const") || dagvtx_optype(v) == spoc_type_thr) {
     list vtx_params = freia_get_vertex_params(v);
     FOREACH(expression, arg, vtx_params) {
       if (is_param_dynamic(arg))
         return true;
     }
   }
   return false;
 }

References dagvtx_optype(), f(), FOREACH, freia_get_vertex_params(), get_freia_api_vtx(), is_param_dynamic(), and spoc_type_thr.

Referenced by sc_delimiter(), and sigmac_params_decl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_param_dynamic()

static bool is_param_dynamic ( expression arg )

static

Determine if an argument contains references to other variables (dirty hack based on isalpha)

Definition at line 101 of file freia_sigmac.c.

                                              {
   string s = expression_to_string(arg);
   bool is_dyn = false;
   unsigned int i;
   for (i = 0; i < strlen(s); i++)
     if (isalpha(s[i]))
       is_dyn = true;
   return is_dyn;
 }

References expression_to_string().

Referenced by has_vtx_dynamic_params(), and sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sc_delimiter()

static void sc_delimiter	(	string_buffer	sb,
		const string	title
	)

static

Generate a 3 lines commented code delimiter with a centered title.

); int a = (columns - l - 2) / 2; for (i = 0; i < a; i++) sb_cat(sb, "#"); if (!(l % 2)) sb_cat(sb, " ", title, " #"); else sb_cat(sb, " ", title, " "); for (i = 0; i < a; i++) sb_cat(sb, "#"); sb_cat(sb, "

); for (i = 0; i < columns; i++) sb_cat(sb, "#"); sb_cat(sb, "

If vtx is compound, returns the id of correspondant connected component. Else returns -1.

Main loop looping over the list of vertices of the given dag

call this helper for dag d ??? currently non constant parameters are NOT handled at all.

we generate an application subgraph with 4 pipes for every independant dag

Generate a root subgraph (equivalent of the main function) which initialize the image data and calls the application subgraphs

two i/o pipes for each predefined controller and four for each dag (2 for images i/o, 2 for parameters i/o)

we only need one instance of the following agents because several commands can be sent throughout the same pipe

Definition at line 351 of file freia_sigmac.c.

References _intFMT, freia_api_t::arg_misc_in, cat, CONS, dag_dot_dump_prefix(), dag_dump(), dag_fix_image_reuse(), dag_inputs, dag_no_image_operation(), dag_outputs, dag_split_on_scalars(), dag_statements(), dag_vertex_preds(), dag_vertices, dagvtx_image(), dagvtx_is_measurement_p(), dagvtx_nb_dump(), dagvtx_number(), dagvtx_operation(), dagvtx_opid(), dagvtx_optype(), dagvtx_statement(), dagvtx_succs, dg, entity_to_expression(), entity_undefined_p, expression_domain, expression_to_string(), f(), FOREACH, fprintf(), free(), freia_allocate_new_images_if_needed(), freia_create_helper_function(), freia_dag_optimize(), freia_get_vertex_params(), freia_insert_added_stats(), freia_migrate_statements(), freia_ok(), freia_sigmac_compile_calls(), FREIA_SIGMAC_SC_INCLUDES, gen_free_list(), gen_full_copy_list(), gen_in_list_p(), gen_length(), gen_make_list(), gen_nconc(), gen_nreverse(), gen_nth(), gen_position(), get_bool_property(), get_freia_api_vtx(), get_int_property(), has_vtx_dynamic_params(), HASH_FOREACH, hash_pointer, hash_put(), hash_table_free(), hash_table_make(), HELPER, helper_file_name(), hwac_replace_statement(), i2a(), init, input(), sigmac_hw_t::inst_prefix, int, int_to_expression(), is_param_dynamic(), LIST, local_name_to_top_level_entity(), MAIN_PATH, make_call(), sigmac_hw_t::mergeable, module, n_dags, N_PREDEFINED_CONTROLLERS, NIL, out, PARAM_T, pips_assert, pips_debug, PIXEL_T, REPLICATION_AGENT, safe_fopen(), same_string_p, sb_cat, sb_prf, sc_get_params_values(), sc_get_port_id(), sc_inst(), sc_kernel_specific_agent(), sc_vtx_tostring(), set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, set_size(), set_union(), freia_api_t::sigmac, SIGMAC_CONNECT, SIGMAC_HELPER, SIGMAC_INSTANTIATE, sigmac_name_instances(), sigmac_params_decl(), spoc_type_thr, strdup(), string_buffer_empty_p(), string_buffer_free(), string_buffer_make(), string_buffer_reset(), string_buffer_to_file(), string_buffer_to_string(), string_buffer_to_string_reverse(), and strupper().

◆ sc_get_params_values()

static list sc_get_params_values	(	dagvtx	vtx,
		hash_table	hparams,
		int *	nparams
	)

static

Returns a list of values of one dagvtx misc input parameters.

Definition at line 130 of file freia_sigmac.c.

                                                                                {
   vtxcontent vtc = dagvtx_content(vtx);
   statement stm = pstatement_statement(vtxcontent_source(vtc));
   call c = freia_statement_to_call(stm);
  
   // list of misc param values
   return freia_extract_params(dagvtx_opid(vtx), call_arguments(c), NULL, NULL,
                               hparams, nparams);
 }

References call_arguments, dagvtx_content, dagvtx_opid(), freia_extract_params(), freia_statement_to_call(), pstatement_statement, and vtxcontent_source.

Referenced by sc_delimiter(), and sigmac_params_decl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sc_get_port_id()

static int sc_get_port_id	(	dagvtx	current_vtx,
		dagvtx	succ,
		dag	dg
	)

static

Helper function determine the input port of the succ dagvtx to be connected to the output port of current_vtx dagvtx succ must be in dagvtx_succs(current_vtx)

Definition at line 344 of file freia_sigmac.c.

                                                                    {
   return gen_position(current_vtx, dag_vertex_preds(dg, succ)) - 1;
 }

References dag_vertex_preds(), dg, and gen_position().

Referenced by sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sc_inst()

static void sc_inst	(	string_buffer	sb,
		const dagvtx	v,
		const hash_table	htid,
		const hash_table	hparams,
		string	miscparams,
		bool	is_dynamic
	)

static

Generate the instanciation of an agent in the forme "agent instname = new agentname (parameters)".

Definition at line 281 of file freia_sigmac.c.

                                      {
   const freia_api_t *f = get_freia_api_vtx(v);
   string_buffer sbinst = string_buffer_make(true);
  
   // beginning of declaration
   sb_cat(sbinst, f->sigmac.agent_name);
  
   if (is_dynamic)
     sb_cat(sbinst, "_dyn");
  
   sb_prf(sbinst, "(%s", f->sigmac.agent_arg);
  
   // completing with misc arguments
   if ((f->arg_misc_in + f->arg_misc_out) && hparams) {
     if (is_dynamic)
       sb_cat(sbinst, ", height");
     else {
       list largs = freia_get_vertex_params(v);
       FOREACH(expression, arg, largs) {
         sb_cat(sbinst, ", ", hash_get(hparams, arg));
         if (freia_convolution_p(v))
           break;
       }
     }
     // add manually more arguments
     if (miscparams)
       sb_cat(sbinst, ", ", miscparams);
   }
   sb_cat(sbinst, ")");
  
   if (get_bool_property("HWAC_SIGMAC_SPECIFIC_MORPHO") &&
       dagvtx_optype(v) == spoc_type_poc) {
  
     string_buffer_reset(sbinst);
     if (same_string_p(f->compact_name, "E8"))
       sb_cat(sbinst, "erode_");
     else if (same_string_p(f->compact_name, "D8"))
       sb_cat(sbinst, "dilate_");
     else if (same_string_p(f->compact_name, "conv"))
       sb_cat(sbinst, "convole_");
     list largs = freia_get_vertex_params(v);
     FOREACH(expression, arg, largs) {
       sb_prf(sbinst, "%s_%d(width, height", hash_get(hparams, arg), n_dags);
       if (freia_convolution_p(v)) // convolution needs the kernel
         sb_prf(sbinst, ", %s", hash_get(hparams, arg));
       sb_prf(sbinst, ")");
       break; // there is only 1 argument
     }
   }
  
   sb_prf(sb, SIGMAC_INSTANTIATE("%s", "%s"), sc_vtx_tostring(v, htid),
          string_buffer_to_string(sbinst));
  
   string_buffer_free(&sbinst);
 }

References dagvtx_optype(), f(), FOREACH, freia_convolution_p(), freia_get_vertex_params(), get_bool_property(), get_freia_api_vtx(), hash_get(), n_dags, same_string_p, sb_cat, sb_prf, sc_vtx_tostring(), SIGMAC_INSTANTIATE, spoc_type_poc, string_buffer_free(), string_buffer_make(), string_buffer_reset(), and string_buffer_to_string().

Referenced by sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sc_kernel_compute_loop()

static bool sc_kernel_compute_loop	(	string_buffer	sb_morpho,
		const dagvtx	vtx,
		string	kname
	)

static

Print a kernel customized inner loop from a morphological kernel.

Definition at line 157 of file freia_sigmac.c.

                                                  {
   intptr_t k[9];
  
   if (dagvtx_optype(vtx) != spoc_type_poc)
     return false;
  
   bool b = freia_extract_kernel_vtx(vtx, true, &k[0], &k[1], &k[2], &k[3],
                                     &k[4], &k[5], &k[6], &k[7], &k[8]);
  
   string row[3] = {"olid", "clid", "ilid"};
   int i, j;
  
   sb_prf(sb_morpho, "\n"
                     "#define %s_%d(OPR)\t\t\t\t\\\n",
          kname, n_dags);
   for (i = 0; i < 3; i++)
     for (j = 0; j < 3; j++)
       if (k[3 * i + j]) {
         string neighbor = strdup(cat("buffer[", row[i], "][i+", i2a(j), "]"));
         sb_prf(sb_morpho, "ret = PIXEL_ ## OPR(ret, %s);\t\\\n", neighbor,
                neighbor);
       }
   sb_prf(sb_morpho, "\nCUSTOM_MORPHO_AGENT(%s_%d, " PIXEL_T ")\n"
                     "\n",
          kname, n_dags);
  
   return b;
 }

References cat, dagvtx_optype(), freia_extract_kernel_vtx(), i2a(), intptr_t, n_dags, PIXEL_T, sb_prf, spoc_type_poc, and strdup().

Referenced by sc_kernel_specific_agent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sc_kernel_specific_agent()

static void sc_kernel_specific_agent	(	string_buffer	sb_morpho,
		hash_table	hparams,
		const dag	dg
	)

static

Definition at line 187 of file freia_sigmac.c.

                                                                        {
   list lparams = NIL;
  
   FOREACH(dagvtx, vtx, dag_vertices(dg)) {
  
     if (dagvtx_optype(vtx) != spoc_type_poc)
       continue;
  
     list vtx_param_vars = freia_get_vertex_params(vtx);
  
     // tests if argument already declared
     string parname =
         (string)hash_get(hparams, EXPRESSION(gen_nth(0, vtx_param_vars)));
     if (gen_in_list_p(parname, lparams))
       continue;
     lparams = CONS(string, parname, lparams);
  
     sc_kernel_compute_loop(sb_morpho, vtx, parname);
   }
 }

References CONS, dag_vertices, dagvtx_optype(), dg, EXPRESSION, FOREACH, freia_get_vertex_params(), gen_in_list_p(), gen_nth(), hash_get(), lparams, NIL, sc_kernel_compute_loop(), and spoc_type_poc.

Referenced by sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sc_print_kernel()

static bool sc_print_kernel	(	string_buffer	sb_par,
		dagvtx	v
	)

static

Print the value of a morphological kernel extracted from a dagvtx.

Definition at line 143 of file freia_sigmac.c.

                                                             {
   intptr_t k[9];
   bool b = freia_extract_kernel_vtx(v, true, &k[0], &k[1], &k[2], &k[3], &k[4],
                                     &k[5], &k[6], &k[7], &k[8]);
   sb_cat(sb_par, "{ ");
   for (int i = 0; i < 8; i++)
     sb_prf(sb_par, "%d, ", k[i]);
   sb_prf(sb_par, "%d }", k[8]);
   return b;
 }

References freia_extract_kernel_vtx(), intptr_t, sb_cat, and sb_prf.

Referenced by sigmac_params_decl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sc_vtx_tostring()

static string sc_vtx_tostring	(	const dagvtx	v,
		const hash_table	htid
	)

static

Generate a unique string per dagvtx consisting in.

one short name, shared by all the dagvtx with the same freia_api_t
one integer, different for every dagvtx with the same freia_api_t

Definition at line 92 of file freia_sigmac.c.

                                                                      {
   string r = get_freia_api_vtx(v)->sigmac.inst_prefix;
   _int n = (_int)hash_get(htid, v);
   return strdup(cat(r, i2a(n)));
 }

References cat, get_freia_api_vtx(), hash_get(), i2a(), sigmac_hw_t::inst_prefix, freia_api_t::sigmac, and strdup().

Referenced by sc_delimiter(), and sc_inst().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sigmac_name_instances()

static void sigmac_name_instances	(	dag	dg,
		hash_table	htid
	)

static

Populates the hash table htid: one dagvtx is linked to an unique id depending on its freia_api_t.

Definition at line 61 of file freia_sigmac.c.

                                                            {
   _int nb_op;
   const freia_api_t *f;
  
   // freia_api_t * -> number of encoutered vertices
   hash_table htinst = hash_table_make(hash_pointer, 16);
  
   FOREACH(dagvtx, vtx, dag_vertices(dg)) {
     f = get_freia_api_vtx(vtx);
     if (!f)
       continue;
  
     // initializating hash_table htinst
     if (!hash_defined_p(htinst, f))
       hash_put(htinst, f, (void *)(_int)0);
  
     // new instance id = total nb of instances of the same operation
     nb_op = (_int)hash_get(htinst, f);
     hash_put(htid, vtx, (void *)nb_op);
     // updating nb of instances for current operation
     nb_op++;
     hash_update(htinst, f, (void *)nb_op);
   }
  
   hash_table_free(htinst);
 }

References dag_vertices, dg, f(), FOREACH, get_freia_api_vtx(), hash_defined_p(), hash_get(), hash_pointer, hash_put(), hash_table_free(), hash_table_make(), and hash_update().

Referenced by sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sigmac_params_decl()

static void sigmac_params_decl	(	string_buffer	sb_par,
		dag	dg,
		hash_table	hparams,
		int *	pnparams
	)

static

Generates the constant parameters declaration.

Definition at line 211 of file freia_sigmac.c.

                                               {
   // dirty workaround preventing deblocking convolutions
   // to declare several times the same parameter
   list lparams = NIL;
   FOREACH(dagvtx, vtx, dag_vertices(dg)) {
  
     if (gen_in_list_p(vtx, dag_inputs(dg)) || dagvtx_is_measurement_p(vtx))
       continue;
  
     // list of misc param values
     list vtx_param_vals = sc_get_params_values(vtx, hparams, pnparams);
     // list of freia misc param names
     list vtx_param_vars = freia_get_vertex_params(vtx);
  
 #ifdef DEBUG_INFO
     const freia_api_t *f = get_freia_api_vtx(vtx);
     sb_prf(sb_par, "// nb args for type %s : %d/%d, in %d, out %d\n",
            f->sigmac.agent_name, gen_length(vtx_param_vals),
            gen_length(vtx_param_vars), f->arg_misc_in, f->arg_misc_out);
     FOREACH(expression, arg, vtx_param_vars) {
       sb_prf(sb_par, "// %s\n", expression_to_string(arg));
     }
     FOREACH(expression, arg, vtx_param_vals) {
       sb_prf(sb_par, "// %s\n", expression_to_string(arg));
     }
 #endif
  
     bool dynamic_agent = has_vtx_dynamic_params(vtx);
  
     // misc params declaration
     unsigned int i = 0;
     FOREACH(expression, arg, vtx_param_vals) {
  
       // tests if argument already declared
       string parname =
           (string)hash_get(hparams, EXPRESSION(gen_nth(i, vtx_param_vars)));
       if (gen_in_list_p(parname, lparams))
         continue;
       lparams = CONS(string, parname, lparams);
  
       if (!dynamic_agent) {
         // print parameter type (in SigmaC, everything is int16_t)
         sb_cat(sb_par, "    " PIXEL_T);
  
         // print parameter pips name
         sb_prf(sb_par, " %s",
                hash_get(hparams, EXPRESSION(gen_nth(i, vtx_param_vars))));
  
         // print parameter value
         if (dagvtx_optype(vtx) == spoc_type_poc) {
           // kernel vtx have only one misc parameter
           sb_cat(sb_par, "[9]", " = ");
           sc_print_kernel(sb_par, vtx); // get & print kernel
         } else
           sb_prf(sb_par, " = %s", expression_to_string(arg));
  
         sb_cat(sb_par, ";\n");
  
         if (freia_convolution_p(vtx))
           break;
         i++;
       }
     } // FOREACH(expression, arg, vtx_param_vals)
   }
 }

References CONS, dag_inputs, dag_vertices, dagvtx_is_measurement_p(), dagvtx_optype(), dg, EXPRESSION, expression_to_string(), f(), FOREACH, freia_convolution_p(), freia_get_vertex_params(), gen_in_list_p(), gen_length(), gen_nth(), get_freia_api_vtx(), has_vtx_dynamic_params(), hash_get(), lparams, NIL, PIXEL_T, sb_cat, sb_prf, sc_get_params_values(), sc_print_kernel(), and spoc_type_poc.

Referenced by sc_delimiter().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ n_dags

int n_dags = 0

static

Definition at line 56 of file freia_sigmac.c.

Referenced by freia_compile(), mppa_dag_maybe_split_instrs_cmd(), mppa_dag_split(), sc_delimiter(), sc_inst(), and sc_kernel_compute_loop().

Macros

Functions

Variables

Macro Definition Documentation

◆ MAIN_PATH

◆ N_PREDEFINED_CONTROLLERS

◆ REPLICATION_AGENT

◆ SIGMAC_CONNECT

◆ SIGMAC_HELPER

◆ SIGMAC_INSTANTIATE

Function Documentation

◆ has_vtx_dynamic_params()

◆ is_param_dynamic()

◆ sc_delimiter()

◆ sc_get_params_values()

◆ sc_get_port_id()

◆ sc_inst()

◆ sc_kernel_compute_loop()

◆ sc_kernel_specific_agent()

◆ sc_print_kernel()

◆ sc_vtx_tostring()

◆ sigmac_name_instances()

◆ sigmac_params_decl()

Variable Documentation

◆ n_dags