freia_mppa.c File Reference

#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "ri-util.h"
#include "ri.h"
#include "prettyprint.h"
#include "properties.h"
#include "freia.h"
#include "hwac.h"
#include "freia_mppa.h"

Include dependency graph for freia_mppa.c:

Go to the source code of this file.

Macros
#define	MPPA_DEFAULT_SMEM_SLOTS   4
	Default number of memory slots. More...
#define	SMEM_SLOT_UNDEFINED   get_int_property("HWAC_MPPA_MAX_SMEM_SLOTS")
	Placeholder for an undefined slot. More...

Functions
static _int	get_free_slot ()
	Get first unused SMEM slot. More...
static _int	get_output_slot (dagvtx vtx)
	Get output slot used by input vertex. More...
static _int	get_a_smem_slot (const dagvtx vtx, hash_table slot_uses_ht)
	Provide a valid unused SMEM slot and link it to vertex. More...
static _int	reuse_pred_slot (const dagvtx vtx, const list preds, hash_table slot_uses_ht)
	Try to find a reusable memory slot for in-place operators. More...
static _int	use_output_slot (const dagvtx vtx, hash_table slot_uses_ht)
	Provide vertex used SMEM slot, update uses table. More...
static void	process_used_slots (list vtx_preds, hash_table slot_uses_ht)
	Update preds usage table, unused slot list. More...
static string	dots2us (string str)
	Replace dots in string with underscores. More...
static list	mppa_helper_args_params (const dag cdg, string *params)
	Build a dag list of arguments and a string of corresponding parameters. More...
static void	mppa_call_helper (const dag dg, const string fname, unsigned int dagi, list largs)
	Replace FREIA calls by PIPS generated ones. More...
static void	mppa_compile_dag (const string module, const dag cdg, const string fname, const int dagi, FILE *const helper)
	Generate an optimized, FREIA-MPPA low level version of this dag. More...
static list	mppa_dag_split (const dag dg, unsigned int n_dags, unsigned int n_vtx_dag)
	Split a dag into several subdags. More...
static list	mppa_dag_maybe_split_instrs_cmd (const dag dg)
	Split a dag in several sub-dags if too large. More...
list	freia_mppa_compile_calls (string module, dag fulld, sequence sq, list ls, const hash_table occs, hash_table exchanges, const set output_images, FILE *helper_file, __attribute__((__unused__)) set helpers, int number)
	Compile one dag with AIPO optimizations. More...

Variables
static dagvtx *	smem_slot_users
	Array of vertices using SMEM slots (indices) as output. More...

Macro Definition Documentation

MPPA_DEFAULT_SMEM_SLOTS

#define MPPA_DEFAULT_SMEM_SLOTS   4

Default number of memory slots.

Definition at line 45 of file freia_mppa.c.

SMEM_SLOT_UNDEFINED

#define SMEM_SLOT_UNDEFINED   get_int_property("HWAC_MPPA_MAX_SMEM_SLOTS")

Placeholder for an undefined slot.

Definition at line 50 of file freia_mppa.c.

Function Documentation

dots2us()

static string dots2us ( string  str )

static

Replace dots in string with underscores.

Parameters

[in,out]

str

allocated string with (or without) dots

Returns

input string

Definition at line 194 of file freia_mppa.c.

                                  {
  unsigned long len = strlen(str);
  for (unsigned int i = 0; i < len; i++) {
    if (str[i] == '.') {
      str[i] = '_';
    }
  }
  return str;
}

Referenced by mppa_compile_dag(), and mppa_helper_args_params().

Here is the caller graph for this function:

freia_mppa_compile_calls()

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

Compile one dag with AIPO optimizations.

Parameters

ls	statements underlying the full dag
occs	image occurences
exchanges	statements to exchange because of dependences

Returns

the list of allocated intermediate images

split on scalars

split large dags

Definition at line 711 of file freia_mppa.c.

                                          {
 
  pips_debug(3, "considering %d statements\n", (int)gen_length(ls));
  pips_assert("some statements", ls);
 
  // intermediate images
  hash_table init = hash_table_make(hash_pointer, 0);
  list new_images = dag_fix_image_reuse(fulld, init, occs);
 
  // about aipo statistics: no helper file to put them...
  list added_before = NIL, added_after = NIL;
  freia_dag_optimize(fulld, exchanges, &added_before, &added_after);
 
  // dump final optimised dag
  dag_dot_dump_prefix(module, "dag_cleaned_", number, fulld, added_before,
                      added_after);
 
  string fname_fulldag = strdup(cat(module, "_mppa", HELPER, i2a(number)));
 
  /* split on scalars */
  list ldss = dag_split_on_scalars(
      fulld, NULL, NULL, (gen_cmp_func_t)dagvtx_ordering, NULL, output_images);
 
  pips_debug(3, "dag initial split in %d dags\n", (int)gen_length(ldss));
 
  int dagi = 0;
 
  set stats = set_make(set_pointer), dones = set_make(set_pointer);
 
  FOREACH(dag, dg, ldss) {
 
    if (dag_no_image_operation(dg)) {
      continue;
    }
 
    // fix statements connexity
    dag_statements(stats, dg);
    freia_migrate_statements(sq, stats, dones);
    set_union(dones, dones, stats);
 
    /* split large dags */
    list sub_dags = mppa_dag_maybe_split_instrs_cmd(dg);
 
    FOREACH(dag, subdg, sub_dags) {
      mppa_compile_dag(module, subdg, fname_fulldag, dagi, helper_file);
      dagi++;
    }
  }
 
  set_free(stats);
  set_free(dones);
 
  // now may put actual allocations, which messes up statement numbers
  list reals =
      freia_allocate_new_images_if_needed(ls, new_images, occs, init, NULL);
 
  // ??? should it be NIL because it is not useful in AIPO->AIPO?
  freia_insert_added_stats(ls, added_before, true);
  added_before = NIL;
  freia_insert_added_stats(ls, added_after, false);
  added_after = NIL;
 
  // cleanup
  gen_free_list(new_images);
  hash_table_free(init);
 
  return reals;
}

References cat, dag_dot_dump_prefix(), dag_fix_image_reuse(), dag_no_image_operation(), dag_split_on_scalars(), dag_statements(), dagvtx_ordering(), dg, FOREACH, freia_allocate_new_images_if_needed(), freia_dag_optimize(), freia_insert_added_stats(), freia_migrate_statements(), gen_free_list(), gen_length(), hash_pointer, hash_table_free(), hash_table_make(), HELPER, i2a(), init, module, mppa_compile_dag(), mppa_dag_maybe_split_instrs_cmd(), NIL, pips_assert, pips_debug, set_free(), set_make(), set_pointer, set_union(), and strdup().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

get_a_smem_slot()

static _int get_a_smem_slot ( const dagvtx  vtx, hash_table  slot_uses_ht  )

static

Provide a valid unused SMEM slot and link it to vertex.

Parameters

[in]	vtx	vertex in need of a memory slot
[out]	slot_users_ht	number of uses for this slot

Returns

valid SMEM slot

get first unused slot

link this slot to current vtx for later use

several successors, slot should be stored

and the consumer should deal itself with freeing the slot

Definition at line 98 of file freia_mppa.c.

                                                                       {
 
  /* get first unused slot */
  _int slot = get_free_slot();
  /* link this slot to current vtx for later use */
  smem_slot_users[slot] = vtx;
 
  _int nb_succs = gen_length(dagvtx_succs(vtx));
  if (nb_succs > 0) {
    /* several successors, slot should be stored */
    hash_put(slot_uses_ht, vtx, (void *)nb_succs);
    /* and the consumer should deal itself with freeing the slot */
  }
 
  return slot;
}

References dagvtx_succs, gen_length(), get_free_slot(), hash_put(), and smem_slot_users.

Referenced by mppa_compile_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

get_free_slot()

static _int get_free_slot ( )

static

Get first unused SMEM slot.

Definition at line 62 of file freia_mppa.c.

                            {
  unsigned int max_smem_slots = get_int_property("HWAC_MPPA_MAX_SMEM_SLOTS");
  _int slot = SMEM_SLOT_UNDEFINED;
  for (unsigned int i = 0; i < max_smem_slots; i++) {
    if (smem_slot_users[i] == NULL) {
      slot = i;
      break;
    }
  }
  pips_assert("enough SMEM slots", slot != SMEM_SLOT_UNDEFINED);
  return slot;
}

References get_int_property(), pips_assert, SMEM_SLOT_UNDEFINED, and smem_slot_users.

Referenced by get_a_smem_slot().

Here is the call graph for this function:

Here is the caller graph for this function:

get_output_slot()

static _int get_output_slot ( dagvtx  vtx )

static

Get output slot used by input vertex.

Definition at line 78 of file freia_mppa.c.

                                        {
  unsigned int max_smem_slots = get_int_property("HWAC_MPPA_MAX_SMEM_SLOTS");
  _int slot = SMEM_SLOT_UNDEFINED;
  for (unsigned int i = 0; i < max_smem_slots; i++) {
    if (smem_slot_users[i] == vtx) {
      slot = i;
      break;
    }
  }
  return slot;
}

References get_int_property(), SMEM_SLOT_UNDEFINED, and smem_slot_users.

Referenced by mppa_compile_dag(), process_used_slots(), reuse_pred_slot(), and use_output_slot().

Here is the call graph for this function:

Here is the caller graph for this function:

mppa_call_helper()

static void mppa_call_helper ( const dag  dg, const string  fname, unsigned int  dagi, list  largs  )

static

Replace FREIA calls by PIPS generated ones.

Parameters

[in]	dg	dag of several FREIA operations
[in]	fname	function to call
[in]	split	splitted dag index

Returns

void

Definition at line 317 of file freia_mppa.c.

                                                            {
  bool call_inserted = false;
  FOREACH(dagvtx, v, dag_vertices(dg)) {
    _int op = dagvtx_opid(v);
    if (op == 0)
      continue;
    statement st = dagvtx_statement(v);
    if (call_inserted)
      hwac_replace_statement(st, freia_ok(), true);
    else {
      entity mppa_helper = local_name_to_top_level_entity(fname);
      string fname_real = strdup(cat(fname, "_", i2a(dagi)));
      if (entity_undefined_p(mppa_helper))
        mppa_helper = freia_create_helper_function(fname_real, NIL);
      hwac_replace_statement(st, make_call(mppa_helper, largs), false);
      call_inserted = true;
    }
  }
}

References cat, dag_vertices, dagvtx_opid(), dagvtx_statement(), dg, entity_undefined_p, FOREACH, freia_create_helper_function(), freia_ok(), hwac_replace_statement(), i2a(), local_name_to_top_level_entity(), make_call(), NIL, and strdup().

Referenced by mppa_compile_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

mppa_compile_dag()

static void mppa_compile_dag ( const string  module, const dag  cdg, const string  fname, const int  dagi, FILE *const  helper  )

static

Generate an optimized, FREIA-MPPA low level version of this dag.

Parameters

[in]	module	current module name
[in]	cdg	current dag
[in]	fname	function name
[in]	dagi	dag index
[in,out]	helper	file to host the output

Returns

void

debug

DEBUG_INFO

slot -> dagvtx user or NULL if free

prologue

global?

global?

set number of SMEM slots using property set to non-default value

input nodes

put image in an unused SMEM slot

non-input nodes

loop over preds to get slots

reductions results

remove '&' in first position

good memory management \o/

store vtx -> offset variable id

declare offset variable

there is an output image

preds outputs are reused after

and maybe some extra input parameters...

deal with structuring elements

se is statically known, do some partial eval

use a function to convert se to binary constant

deal with every parameter of other-than-morphological ops

partial eval threshold third parameter to redirect to relevant MPPA kernel

hack: overwrite current kernel...

skip writing third parameter (avoid obvious overflow)

add put instructions for output nodes (releases slot)

effectively launch computation

post-process reductions offset

epilogue

dump to helper file

replace statements

cleanup

Definition at line 349 of file freia_mppa.c.

                                                 {
 
  fprintf(helper, "\n// module=%s fname=%s split=%d\n", module, fname, dagi);
 
  /* debug */
#ifdef DEBUG_INFO
  dag_dump(stdout, fname, cdg);
#endif /* DEBUG_INFO */
 
  string_buffer sb_cmd = string_buffer_make(true);
  string curr_cmd = strdup(cat("cmd", i2a(dagi)));
  unsigned int meas_ctr = 0;
  hash_table meas_off_ht = hash_table_make(hash_pointer, 16);
  unsigned int instr_ctr = 0;
  hash_table slots_used_ht = hash_table_make(hash_pointer, 16);
  list ordered_vtx = gen_nreverse(gen_copy_seq(dag_vertices(cdg)));
 
  unsigned int max_smem_slots = get_int_property("HWAC_MPPA_MAX_SMEM_SLOTS");
 
  /* slot -> dagvtx user or NULL if free */
  smem_slot_users = malloc(max_smem_slots * sizeof(dagvtx));
  for (unsigned int i = 0; i < max_smem_slots; i++) {
    smem_slot_users[i] = NULL;
  }
 
  string fparams;
  list largs = mppa_helper_args_params(cdg, &fparams);
 
  /* prologue */
  sb_prf(sb_cmd, "int %s_%d(%s) {\n", fname, dagi, fparams);
  sb_cat(sb_cmd, "\n");
  sb_cat(sb_cmd, "  mppa_cc_instr_t *instrs;\n"); /* global? */
  sb_cat(sb_cmd, "  unsigned int i = 0;\n");      /* global? */
  sb_prf(sb_cmd, "  mppa_cc_cmd_t %s;\n", curr_cmd);
  sb_prf(sb_cmd, "  instrs = %s.instrs;\n", curr_cmd);
  /* set number of SMEM slots using property set to non-default value */
  if (max_smem_slots != MPPA_DEFAULT_SMEM_SLOTS) {
    pips_assert("non-null number of SMEM slots", max_smem_slots > 0);
    pips_assert("enough number of SMEM slots", max_smem_slots < 255);
    sb_cat(sb_cmd, "  /* override default SMEM slots number */\n");
    sb_prf(sb_cmd, "  mppa_smem_slots = %d;\n", max_smem_slots);
  }
  sb_cat(sb_cmd, "\n");
 
  FOREACH(dagvtx, vtx, ordered_vtx) {
 
    const freia_api_t *fapi = get_freia_api_vtx(vtx);
    list preds = dag_vertex_preds(cdg, vtx);
 
    /* input nodes */
    if (same_string_p(dagvtx_operation(vtx), "undefined")) {
      entity imin = dagvtx_image(vtx);
      sb_cat(sb_cmd, "  instrs[i].kind = MPPA_CMD_GET_IO_TILE;\n");
      sb_prf(sb_cmd,
             "  instrs[i].com.io_pos = ((io_image_h *)%s->mppa_ptr)->pos;\n",
             expression_to_string(entity_to_expression(imin)));
      /* put image in an unused SMEM slot */
      sb_prf(sb_cmd, "  instrs[i].com.cc_pos = %d;\n",
             get_a_smem_slot(vtx, slots_used_ht));
    }
 
    else { /* non-input nodes */
      sb_prf(sb_cmd, "  instrs[i].kind = MPPA_CMD_EXECUTE_KERNEL;\n");
      sb_prf(sb_cmd, "  instrs[i].opr.kernel = %s;\n", fapi->mppa.kernel_enum);
 
      /* loop over preds to get slots */
      unsigned int predi = 0;
      FOREACH(dagvtx, pred, preds) {
        sb_prf(sb_cmd, "  instrs[i].opr.pos[%d] = %d; /* input */\n", predi + 1,
               use_output_slot(pred, slots_used_ht));
        predi++;
      }
 
      if (dagvtx_is_measurement_p(vtx)) { /* reductions results */
        string measvar =
            expression_to_string(EXPRESSION(CAR(freia_get_vertex_params(vtx))));
        /* remove '&' in first position */
        if (measvar[0] == '&') {
          measvar = &measvar[1]; /* good memory management \o/ */
        }
        sb_prf(sb_cmd, "  instrs[i].opr.red_dst[0] = %s; /* result */\n",
               measvar);
        if (fapi->arg_misc_out > 1) {
          /* store vtx -> offset variable id */
          hash_put(meas_off_ht, vtx, (void *)(_int)meas_ctr);
          /* declare offset variable */
          sb_prf(sb_cmd, "  uint32_t meas_off%d;\n", meas_ctr);
          sb_prf(sb_cmd,
                 "  instrs[i].opr.red_dst[1] = &meas_off%d; /* offset */\n",
                 meas_ctr);
          meas_ctr++;
        }
      }
 
      else { /* there is an output image */
 
        _int slot = reuse_pred_slot(vtx, preds, slots_used_ht);
        if (slot == SMEM_SLOT_UNDEFINED) {
          /* preds outputs are reused after */
          slot = get_a_smem_slot(vtx, slots_used_ht);
        }
 
        sb_prf(sb_cmd, "  instrs[i].opr.pos[0] = %d; /* output */\n", slot);
 
        /* and maybe some extra input parameters... */
 
        if (dagvtx_optype(vtx) == spoc_type_poc) {
          /* deal with structuring elements */
          intptr_t se[9];
          if (freia_extract_kernel_vtx(vtx, true, &se[0], &se[1], &se[2],
                                       &se[3], &se[4], &se[5], &se[6], &se[7],
                                       &se[8])) {
            /* se is statically known, do some partial eval */
            sb_prf(
                sb_cmd, "  instrs[i].opr.scalars[0] = 0b%d%d%d%d%d%d%d%d%d;\n",
                se[0], se[1], se[2], se[3], se[4], se[5], se[6], se[7], se[8]);
          } else {
            /* use a function to convert se to binary constant */
            sb_prf(sb_cmd, "  instrs[i].opr.scalars[0] = se2scal(%s);\n",
                   expression_to_string(
                       EXPRESSION(CAR(freia_get_vertex_params(vtx)))));
          }
        }
 
        else {
          /* deal with every parameter of other-than-morphological ops */
          unsigned int argi = 0;
          FOREACH(expression, expr, freia_get_vertex_params(vtx)) {
            /* partial eval threshold third parameter to redirect to
               relevant MPPA kernel */
            if (argi == 2 && dagvtx_optype(vtx) == spoc_type_thr) {
              if (strcmp(expression_to_string(expr), "1") == 0 ||
                  strcmp(expression_to_string(expr), "true") == 0) {
                /* hack: overwrite current kernel... */
                sb_cat(sb_cmd,
                       "  instrs[i].opr.kernel = MPPA_KERNEL_THRESHOLD_BIN;\n");
              }
              /* skip writing third parameter (avoid obvious overflow) */
              break;
            }
            sb_prf(sb_cmd, "  instrs[i].opr.scalars[%d] = %s;\n", argi,
                   expression_to_string(expr));
            argi++;
          }
        }
      }
    }
 
    /* add put instructions for output nodes (releases slot) */
    if (gen_in_list_p(vtx, dag_outputs(cdg))) {
      sb_prf(sb_cmd, "  i++; /* instr #%u, vtx #%d */\n", instr_ctr,
             dagvtx_number(vtx));
      sb_cat(sb_cmd, "\n");
      instr_ctr++;
 
      entity imout = dagvtx_image(vtx);
      sb_cat(sb_cmd, "  instrs[i].kind = MPPA_CMD_PUT_IO_TILE;\n");
      sb_prf(sb_cmd, "  instrs[i].com.cc_pos = %d;\n", get_output_slot(vtx));
      sb_prf(sb_cmd,
             "  instrs[i].com.io_pos = ((io_image_h *)%s->mppa_ptr)->pos;\n",
             expression_to_string(entity_to_expression(imout)));
    }
 
    process_used_slots(preds, slots_used_ht);
 
    sb_prf(sb_cmd, "  i++; /* instr #%u, vtx #%d */\n", instr_ctr,
           dagvtx_number(vtx));
    sb_cat(sb_cmd, "\n");
 
    instr_ctr++;
    gen_free_list(preds);
  }
 
  unsigned int max_instrs_per_cmd =
      get_int_property("HWAC_MPPA_MAX_INSTRS_CMD");
  pips_assert("cmd can host more instructions",
              instr_ctr <= max_instrs_per_cmd);
 
  /* effectively launch computation */
  sb_cat(sb_cmd, "  /* launch computation... */\n");
  sb_prf(sb_cmd, "  mppa_compute(i, &%s);\n", curr_cmd);
  sb_cat(sb_cmd, "\n");
 
  /* post-process reductions offset */
  HASH_FOREACH(dagvtx, vtx, _int, value, meas_off_ht) {
    list vtx_params = freia_get_vertex_params(vtx);
    string xcoord = expression_to_string(EXPRESSION(gen_nth(1, vtx_params)));
    string ycoord = expression_to_string(EXPRESSION(gen_nth(2, vtx_params)));
    pips_assert("coord var name contains more than '&' char",
                strlen(xcoord) > 1);
    pips_assert("coord var name contains more than '&' char",
                strlen(ycoord) > 1);
    xcoord = dots2us(&xcoord[1]);
    ycoord = dots2us(&ycoord[1]);
    string imin = expression_to_string(entity_to_expression(
        ENTITY(CAR(vtxcontent_inputs(dagvtx_content(vtx))))));
    sb_prf(sb_cmd, "  *%s = meas_off%d %% %s->widthWa;\n", xcoord, value, imin);
    sb_prf(sb_cmd, "  *%s = meas_off%d / %s->widthWa;\n", ycoord, value, imin);
    sb_cat(sb_cmd, "\n");
  }
 
  /* epilogue */
  sb_cat(sb_cmd, "  return 0;\n");
  sb_cat(sb_cmd, "}\n");
 
  /* dump to helper file */
  string_buffer_to_file(sb_cmd, helper);
 
  /* replace statements */
  mppa_call_helper(cdg, fname, dagi, largs);
 
  /* cleanup */
  string_buffer_free(&sb_cmd);
  hash_table_free(meas_off_ht);
  hash_table_free(slots_used_ht);
  free(smem_slot_users);
  gen_free_list(ordered_vtx);
}

References freia_api_t::arg_misc_out, CAR, cat, dag_dump(), dag_outputs, dag_vertex_preds(), dag_vertices, dagvtx_content, dagvtx_image(), dagvtx_is_measurement_p(), dagvtx_number(), dagvtx_operation(), dagvtx_optype(), dots2us(), ENTITY, entity_to_expression(), EXPRESSION, expression_to_string(), FOREACH, fprintf(), free(), freia_extract_kernel_vtx(), freia_get_vertex_params(), gen_copy_seq(), gen_free_list(), gen_in_list_p(), gen_nreverse(), gen_nth(), get_a_smem_slot(), get_freia_api_vtx(), get_int_property(), get_output_slot(), HASH_FOREACH, hash_pointer, hash_put(), hash_table_free(), hash_table_make(), i2a(), intptr_t, mppa_hw_t::kernel_enum, malloc(), module, freia_api_t::mppa, mppa_call_helper(), MPPA_DEFAULT_SMEM_SLOTS, mppa_helper_args_params(), pips_assert, process_used_slots(), reuse_pred_slot(), same_string_p, sb_cat, sb_prf, SMEM_SLOT_UNDEFINED, smem_slot_users, spoc_type_poc, spoc_type_thr, strdup(), string_buffer_free(), string_buffer_make(), string_buffer_to_file(), use_output_slot(), and vtxcontent_inputs.

Referenced by freia_mppa_compile_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

mppa_dag_maybe_split_instrs_cmd()

static list mppa_dag_maybe_split_instrs_cmd ( const dag  dg )

static

Split a dag in several sub-dags if too large.

Parameters

[in]

dag

to split

Returns

list of sub-dags of input dag

ok: dag should not be splitted

not ok: split!

one more if maybe too large

educated guess...

constraints: balanced dags, try not to separate outputs from producers...

Definition at line 672 of file freia_mppa.c.

                                                          {
 
  list res = NIL;
  unsigned int upper_bound = get_int_property("HWAC_MPPA_MAX_INSTRS_CMD");
  unsigned int n_instrs =
      gen_length(dag_vertices(dg)) + gen_length(dag_outputs(dg));
 
  if (n_instrs <= upper_bound) {
    /* ok: dag should not be splitted */
    res = CONS(dag, dg, res);
  } else {
    /* not ok: split! */
    unsigned int n_dags = n_instrs / upper_bound + 1;
    unsigned int n_vtx_dag = n_instrs / n_dags + 1;
 
    /* one more if maybe too large */
    if (n_vtx_dag > upper_bound - 4) { /* educated guess... */
      n_dags++;
      n_vtx_dag = n_instrs / n_dags + 1;
    }
 
    pips_assert("splitted dags are small enough", n_vtx_dag <= upper_bound);
 
    /* constraints: balanced dags, try not to separate outputs from
       producers...  */
    res = mppa_dag_split(dg, n_dags, n_vtx_dag);
  }
  return res;
}

References CONS, dag_outputs, dag_vertices, dg, gen_length(), get_int_property(), mppa_dag_split(), n_dags, NIL, and pips_assert.

Referenced by freia_mppa_compile_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

mppa_dag_split()

static list mppa_dag_split ( const dag  dg, unsigned int  n_dags, unsigned int  n_vtx_dag  )

static

Split a dag into several subdags.

Parameters

[in]	dg	input dag
[in]	n_dags	number of returned sub-dags
[in]	n_vtx_dag	number of vertices per sub-dag

Returns

list of sub-dags

add input nodes

replace by an input node

get the right entity

create an input node of opid 0 (undefined)

add input vertex right before first consumer to optimize memory slots usage

add output nodes

mark vtx as an output node

remove succ from successors list

clean some weird cases when an input vtx is also an output

Definition at line 579 of file freia_mppa.c.

                                                   {
  list res = NIL;
  unsigned int upper_bound = get_int_property("HWAC_MPPA_MAX_INSTRS_CMD");
 
  for (unsigned int i = 0; i < n_dags; i++) {
 
    list vertices = NIL, inputs = NIL, outputs = NIL;
 
    unsigned int vtxi = 0;
    FOREACH(dagvtx, vtx, dag_vertices(dg)) {
      if (vtxi >= i * n_vtx_dag && vtxi < (i + 1) * n_vtx_dag) {
        vertices = CONS(dagvtx, vtx, vertices);
        if (gen_in_list_p(vtx, dag_inputs(dg))) {
          inputs = CONS(dagvtx, vtx, inputs);
        }
        if (gen_in_list_p(vtx, dag_outputs(dg))) {
          outputs = CONS(dagvtx, vtx, outputs);
        }
      }
      vtxi++;
    }
 
    /* add input nodes */
    list to_add = NIL;
    FOREACH(dagvtx, vtx, vertices) {
      FOREACH(dagvtx, pred, dag_vertex_preds(dg, vtx)) {
        if (!gen_in_list_p(pred, vertices)) {
          /* replace by an input node */
          FOREACH(entity, e, vtxcontent_inputs(dagvtx_content(vtx))) {
            /* get the right entity */
            if (e == vtxcontent_out(dagvtx_content(pred))) {
              pips_assert("e is defined", e != entity_undefined);
              /* create an input node of opid 0 (undefined) */
              dagvtx newpred = make_dagvtx(
                  make_vtxcontent(0, 0, make_pstatement_empty(), NIL, e), NIL);
 
              inputs = CONS(dagvtx, newpred, inputs);
              to_add = CONS(dagvtx, newpred, to_add);
 
              dagvtx_succs(newpred) = CONS(dagvtx, vtx, dagvtx_succs(newpred));
            }
          }
        }
      }
    }
    /* add input vertex right before first consumer to optimize memory
       slots usage */
    FOREACH(dagvtx, vtx, to_add) {
      dagvtx first_consumer = DAGVTX(CAR(dagvtx_succs(vtx)));
      vertices = gen_insert_before(vtx, first_consumer, vertices);
    }
 
    /* add output nodes */
    FOREACH(dagvtx, vtx, vertices) {
      FOREACH(dagvtx, succ, dagvtx_succs(vtx)) {
        if (!gen_in_list_p(succ, vertices)) {
          /* mark vtx as an output node */
          outputs = CONS(dagvtx, vtx, outputs);
          /* remove succ from successors list */
          gen_remove(&dagvtx_succs(vtx), succ);
        }
      }
    }
 
    /* clean some weird cases when an input vtx is also an output*/
    FOREACH(dagvtx, vtx, inputs) {
      if (gen_in_list_p(vtx, outputs)) {
        gen_remove(&outputs, vtx);
      }
    }
 
    dag subdg = make_dag(gen_nreverse(inputs), gen_nreverse(outputs),
                         gen_nreverse(vertices));
 
    dag_cleanup_other_statements(subdg);
 
    pips_assert("small subdags",
                (gen_length(dag_vertices(subdg)) +
                 gen_length(dag_outputs(subdg))) <= upper_bound);
 
    res = CONS(dag, subdg, res);
  }
  return res;
}

References CAR, CONS, dag_cleanup_other_statements(), dag_inputs, dag_outputs, dag_vertex_preds(), dag_vertices, DAGVTX, dagvtx_content, dagvtx_succs, dg, entity_undefined, FOREACH, gen_in_list_p(), gen_insert_before(), gen_length(), gen_nreverse(), gen_remove(), get_int_property(), make_dag(), make_dagvtx(), make_pstatement_empty(), make_vtxcontent(), n_dags, NIL, pips_assert, vtxcontent_inputs, and vtxcontent_out.

Referenced by mppa_dag_maybe_split_instrs_cmd().

Here is the call graph for this function:

Here is the caller graph for this function:

mppa_helper_args_params()

static list mppa_helper_args_params ( const dag  cdg, string *  params  )

static

Build a dag list of arguments and a string of corresponding parameters.

Parameters

[in]	cdg	current dag
[out]	args	allocated empty list of arguments (entities)
[out]	fargs	pointer to string of helper parameters

Returns

allocated list of helper call arguments

list of argument expressions

string buffer of helper parameters

loop over input/output nodes and store image variables into list

loop over image expressions to fill string buffer

loop over measure vertices

non partially evaluated structuring elements

pass SE name as helper parameter

post-process parameters

arguments string ends with ", "

replace '&' by '*'

cleanup

Definition at line 213 of file freia_mppa.c.

                                                                   {
 
  /* list of argument expressions */
  list largs = NIL;
 
  /* string buffer of helper parameters */
  string_buffer sb_args = string_buffer_make(true);
 
  /* loop over input/output nodes and store image variables into list */
  set im_done = set_make(set_string);
  FOREACH(dagvtx, vtx, dag_inputs(cdg)) {
    entity in = dagvtx_image(vtx);
    if (in) {
      expression inexpr = entity_to_expression(in);
      if (!set_belong_p(im_done, expression_to_string(inexpr))) {
        largs = CONS(expression, inexpr, largs);
        set_add_element(im_done, im_done, expression_to_string(inexpr));
      }
    }
  }
  largs = gen_nreverse(largs);
  list largsout = NIL;
  FOREACH(dagvtx, vtx, dag_outputs(cdg)) {
    entity out = dagvtx_image(vtx);
    if (out) {
      expression outexpr = entity_to_expression(out);
      if (!set_belong_p(im_done, expression_to_string(outexpr))) {
        largsout = CONS(expression, outexpr, largsout);
        set_add_element(im_done, im_done, expression_to_string(outexpr));
      }
    }
  }
  set_free(im_done);
  largs = gen_nconc(gen_nreverse(largsout), largs);
 
  /* loop over image expressions to fill string buffer */
  FOREACH(expression, imexpr, largs) {
    sb_prf(sb_args, "freia_data2d *%s, ", expression_to_string(imexpr));
  }
 
  /* loop over measure vertices */
  FOREACH(dagvtx, vtx, dag_vertices(cdg)) {
    if (dagvtx_is_measurement_p(vtx)) {
      list measargs = gen_full_copy_list(freia_get_vertex_params(vtx));
      sb_prf(sb_args, "int32_t %s, ",
             expression_to_string(EXPRESSION(CAR(measargs))));
      if (gen_length(measargs) >= 3) {
        string xcoord = expression_to_string(EXPRESSION(gen_nth(1, measargs)));
        string ycoord = expression_to_string(EXPRESSION(gen_nth(2, measargs)));
        sb_prf(sb_args, "uint32_t %s, ", dots2us(xcoord));
        sb_prf(sb_args, "uint32_t %s, ", dots2us(ycoord));
      }
      largs = gen_nconc(largs, measargs);
    }
  }
 
  set se_done = set_make(set_string);
  FOREACH(dagvtx, vtx, dag_vertices(cdg)) {
    /* non partially evaluated structuring elements */
    if (dagvtx_optype(vtx) == spoc_type_poc) {
      intptr_t se[9];
      if (!freia_extract_kernel_vtx(vtx, true, &se[0], &se[1], &se[2], &se[3],
                                    &se[4], &se[5], &se[6], &se[7], &se[8])) {
        /* pass SE name as helper parameter */
        list params = gen_full_copy_list(freia_get_vertex_params(vtx));
        string se = expression_to_string(EXPRESSION(CAR(params)));
        if (!set_belong_p(se_done, se)) {
          sb_prf(sb_args, "int32_t *%s, ", se);
          largs = gen_nconc(largs, params);
          set_add_element(se_done, se_done, se);
        }
      }
    }
  }
  set_free(se_done);
 
  /* post-process parameters */
  string fargs = string_buffer_to_string(sb_args);
  /* arguments string ends with ", " */
  if (fargs[strlen(fargs) - 2] == ',') {
    fargs[strlen(fargs) - 2] = '\0';
  }
  /* replace '&' by '*' */
  for (unsigned int i = 0; i < strlen(fargs); i++) {
    if (fargs[i] == '&') {
      fargs[i] = '*';
    }
  }
  *params = fargs;
 
  /* cleanup */
  string_buffer_free(&sb_args);
  return largs;
}

References CAR, CONS, dag_inputs, dag_outputs, dag_vertices, dagvtx_image(), dagvtx_is_measurement_p(), dagvtx_optype(), dots2us(), entity_to_expression(), EXPRESSION, expression_to_string(), FOREACH, freia_extract_kernel_vtx(), freia_get_vertex_params(), gen_full_copy_list(), gen_length(), gen_nconc(), gen_nreverse(), gen_nth(), intptr_t, NIL, out, params, sb_prf, set_add_element(), set_belong_p(), set_free(), set_make(), set_string, spoc_type_poc, string_buffer_free(), string_buffer_make(), and string_buffer_to_string().

Referenced by mppa_compile_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

process_used_slots()

static void process_used_slots ( list  vtx_preds, hash_table  slot_uses_ht  )

static

Update preds usage table, unused slot list.

Parameters

[in]	vtx_preds	list of predecessors
[out]	slot_users_ht	number of uses

Returns

void

can reuse slot

delete entry in uses ht

Definition at line 174 of file freia_mppa.c.

                                                                        {
  FOREACH(dagvtx, pred, vtx_preds) {
    _int slot = get_output_slot(pred);
    _int rem_uses = (_int)hash_get(slot_uses_ht, pred);
    if (rem_uses == 0) {
      /* can reuse slot */
      smem_slot_users[slot] = NULL;
      /* delete entry in uses ht */
      hash_del(slot_uses_ht, pred);
    }
  }
}

References FOREACH, get_output_slot(), hash_del(), hash_get(), and smem_slot_users.

Referenced by mppa_compile_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

reuse_pred_slot()

static _int reuse_pred_slot ( const dagvtx  vtx, const list  preds, hash_table  slot_uses_ht  )

static

Try to find a reusable memory slot for in-place operators.

Parameters

[in]	vtx	current vertex
[in]	preds	list of predecessors of current vertex
[in,out]	slot_uses_ht	number of uses for this slot

Returns

one of preds slots, or SMEM_SLOT_UNDEFINED

pred slot can be reused

several successors, slot should be stored

Definition at line 124 of file freia_mppa.c.

                                                     {
 
  _int slot = SMEM_SLOT_UNDEFINED;
  if (dagvtx_optype(vtx) == spoc_type_poc) {
    return slot;
  }
  FOREACH(dagvtx, pred, preds) {
    _int pred_rem_use = (_int)hash_get(slot_uses_ht, pred);
    if (pred_rem_use == 0) {
      /* pred slot can be reused */
      slot = get_output_slot(pred);
      smem_slot_users[slot] = vtx;
      hash_update(slot_uses_ht, pred, (void *)(pred_rem_use - 1));
      break;
    }
  }
  _int nb_succs = gen_length(dagvtx_succs(vtx));
  if (nb_succs > 0) {
    /* several successors, slot should be stored */
    hash_put(slot_uses_ht, vtx, (void *)nb_succs);
  }
  return slot;
}

References dagvtx_optype(), dagvtx_succs, FOREACH, gen_length(), get_output_slot(), hash_get(), hash_put(), hash_update(), SMEM_SLOT_UNDEFINED, smem_slot_users, and spoc_type_poc.

Referenced by mppa_compile_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

use_output_slot()

static _int use_output_slot ( const dagvtx  vtx, hash_table  slot_uses_ht  )

static

Provide vertex used SMEM slot, update uses table.

Parameters

[in]	vtx	vertex using an output slot
[out]	slot_uses_ht	number of uses for this slot

Returns

valid SMEM slot

update uses

Definition at line 157 of file freia_mppa.c.

                                                                       {
  _int slot = get_output_slot(vtx);
  _int rem_uses = (_int)hash_get(slot_uses_ht, vtx);
  /* update uses */
  hash_update(slot_uses_ht, vtx, (void *)(rem_uses - 1));
 
  return slot;
}

References get_output_slot(), hash_get(), and hash_update().

Referenced by mppa_compile_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

smem_slot_users

dagvtx* smem_slot_users

static

Array of vertices using SMEM slots (indices) as output.

Links a SMEM slot to a dagvtx user, or NULL if unused

Definition at line 57 of file freia_mppa.c.

Referenced by get_a_smem_slot(), get_free_slot(), get_output_slot(), mppa_compile_dag(), process_used_slots(), and reuse_pred_slot().