comEngine_generate_procCode.c File Reference

#include <stdio.h>
#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "resources.h"
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "text-util.h"
#include "properties.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
#include "phrase_tools.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "phrase_distribution.h"
#include "comEngine.h"
#include "comEngine_generate_code.h"
#include "phrase.h"

Include dependency graph for comEngine_generate_procCode.c:

Go to the source code of this file.

Functions
static list	make_mmcd_stats_from_ref (statement stat, list lSupportedRef, hash_table htOffset, entity transferSize, entity newOuterInd, statement innerStat)
static bool	get_final_offset (list lRefDim, intptr_t offset, int rank, intptr_t *retVal)
static bool	supported_ref_p (reference ref, entity index, hash_table htOffset)
static bool	has_call_stat_inside_flt (statement stat, bool *bHasCallStat)
static void	has_call_stat_inside_rwt (_UNUSED_ statement stat, _UNUSED_ bool *bHasCallStat)
bool	has_call_stat_inside (statement stat)
	comEngine_generate_procCode.c More...
static intptr_t	get_realFifoNum (intptr_t fifoNum)
static entity	get_toggleEnt_from_ref (reference curRef, list lToggleEnt)
static statement	make_mmcd_load_store_stat (string name, expression hreBuff, expression refExp, expression offExp, expression countExp)
static statement	generate_mmcd_stat_from_ref (reference curRef, int offset, expression count, bool bRead, list lToggleEnt)
static void	generate_mmcd_stats_from_ref (list lRef, hash_table htOffset, expression count, list lToggleEnt, list *lReadStats, list *lWriteStats)
statement	make_step_inc_statement (int incNum)
statement	make_loop_step_stat (statement stat, entity newOuterInd)
static bool	has_loop_inside_flt (statement stat, bool *bHasLoop)
static bool	has_loop_inside (statement stat)
static int	alloc_new_slot (entity ent)
statement	make_toggle_mmcd (entity ent)
static int	find_or_create_slot (entity ent)
statement	make_init_newInd_stat (statement stat, entity newInd)
statement	make_transStat (statement stat, entity newOuterInd, entity transferSize, expression bufferSizeExp)
static void	comEngine_replace_reference_in_stat_rwt (expression exp, expression newExp)
void	comEngine_replace_reference_in_stat (statement stat, reference ref, expression new)
static list	make_lStats (statement stat, entity transferSize, statement innerStat, entity newOuterInd, list lSupportedRef, hash_table htOffset, expression bufferSizeExp)
statement	make_exec_mmcd ()
statement	generate_stat_from_ref_list_proc (list lRef, list lToggleEnt, statement stat)
list	generate_stat_from_ref_list_proc_list (list lRef, list lInStats)
void	process_innerStat1_proc (statement stat, entity oldInd, entity newOuterInd, entity newInnerInd)
void	get_supportedRef_proc (statement stat, hash_table htOffset, list *lSupportedRef, list *lUnSupportedRef)
statement	get_call_stat_proc (_UNUSED_ statement stat)
list	make_loop_lStats_proc (statement stat, entity transferSize, statement innerStat, entity newOuterInd, list lSupportedRef, hash_table htOffset, expression bufferSizeExp)
list	add_index_out_effect_proc (loop curLoop, list lStats)
statement	generate_code_test_proc (statement stat)
list	process_gLoopToSync_proc (statement stat, list lInStats)
void	create_realFifo_proc (statement stat, list lRef)
statement	comEngine_generate_procCode (statement externalized_code, _UNUSED_ list l_in, _UNUSED_ list l_out)

Variables
static hash_table	gRealFifo
static entity	gStepEnt
static hash_table	gOldRefToHREFifo
static reference	gRefToReplace

Function Documentation

add_index_out_effect_proc()

list add_index_out_effect_proc	(	loop	curLoop,
		list	lStats
	)

Parameters

curLoop	urLoop
lStats	Stats

Definition at line 1129 of file comEngine_generate_procCode.c.

{
  statement assignStat =
    make_assign_statement(entity_to_expression(loop_index(curLoop)),
                          copy_expression(range_upper(loop_range(curLoop))));
 
  return gen_nconc(lStats, CONS(STATEMENT, assignStat, NIL));
}

References CONS, copy_expression(), entity_to_expression(), gen_nconc(), loop_index, loop_range, make_assign_statement(), NIL, range_upper, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

alloc_new_slot()

static int alloc_new_slot ( entity  ent )

static

f((curFifo == -1) || (curInd == get_int_property("COMENGINE_SIZE_OF_FIFO"))) {

Definition at line 645 of file comEngine_generate_procCode.c.

{
  static intptr_t curFifo = -1;
  static intptr_t curInd = 0;
 
  /*if((curFifo == -1) || (curInd == get_int_property("COMENGINE_SIZE_OF_FIFO")))
    {*/
      curFifo = get_realFifoNum(-1);
 
      curInd = 0;
      //}
 
  hash_put(gEntToHREFifo, ent, (void*)curFifo);
 
  hash_put(gIndToNum, ent, (void*)curInd++);
 
  return curFifo;
}

References gEntToHREFifo, get_realFifoNum(), gIndToNum, hash_put(), and intptr_t.

Referenced by find_or_create_slot(), and make_toggle_mmcd().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_generate_procCode()

statement comEngine_generate_procCode	(	statement	externalized_code,
		_UNUSED_ list	l_in,
		_UNUSED_ list	l_out
	)

Definition at line 1289 of file comEngine_generate_procCode.c.

{
  statement newStat;
 
  // Initialize some global variables
  gOldRefToHREFifo = gRefToHREFifo;
  gRefToHREFifo = hash_table_make(hash_pointer, 0);
  gRealFifo = hash_table_make(hash_pointer, 0);
  gStepEnt =comEngine_make_new_scalar_variable
    (strdup("step"),
                                           make_basic(is_basic_int, (void*)4));
  gGenHRE = false;
 
  // Do the job
  newStat = comEngine_generate_code(externalized_code);
 
  // Add the step variable initialization
  statement stepStat = 
    make_assign_statement(entity_to_expression(gStepEnt),
                          int_to_expression(1));
  
  // Add the start HRE statement
  statement startStat = 
    call_to_statement(make_call(module_name_to_runtime_entity(strdup(START_HRE)),
                                NIL));
 
  // Add the wait HRE statement
  statement waitStat = 
    call_to_statement(make_call(module_name_to_runtime_entity(strdup(WAIT_FOR_HRE)),
                                NIL));
 
  list lStats = gen_make_list(statement_domain,
                              stepStat,
                              newStat,
                              startStat,
                              waitStat,
                              NULL);
 
  newStat = make_block_statement(lStats);
 
  // Fre some global variables
  hash_table_free(gRealFifo);
  hash_table_free(gOldRefToHREFifo);
 
  //printf("final newStat\n");
  //print_statement(newStat);
 
  return newStat;
}

References call_to_statement, comEngine_generate_code(), comEngine_make_new_scalar_variable(), entity_to_expression(), gen_make_list(), gGenHRE, gOldRefToHREFifo, gRealFifo, gRefToHREFifo, gStepEnt, hash_pointer, hash_table_free(), hash_table_make(), int_to_expression(), is_basic_int, make_assign_statement(), make_basic(), make_block_statement(), make_call(), module_name_to_runtime_entity(), NIL, START_HRE, statement_domain, strdup(), and WAIT_FOR_HRE.

Referenced by comEngine_distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_replace_reference_in_stat()

void comEngine_replace_reference_in_stat	(	statement	stat,
		reference	ref,
		expression	new
	)

Parameters

stat	tat
ref	ef
new	ew

Definition at line 871 of file comEngine_generate_procCode.c.

{
  gRefToReplace = ref;
 
  gen_context_recurse(stat, new,
    expression_domain, gen_true2, comEngine_replace_reference_in_stat_rwt);
}

References comEngine_replace_reference_in_stat_rwt(), expression_domain, gen_context_recurse, gen_true2(), gRefToReplace, and ref.

Referenced by generate_code_loop(), make_lInitStats(), make_lSwitchStats(), make_mmcd_stats_from_ref(), process_innerStat1_proc(), regenerate_toggles(), replace_array_ref_with_fifos(), and replace_array_ref_with_fifos2().

Here is the call graph for this function:

Here is the caller graph for this function:

comEngine_replace_reference_in_stat_rwt()

static void comEngine_replace_reference_in_stat_rwt ( expression  exp, expression  newExp  )

static

Definition at line 849 of file comEngine_generate_procCode.c.

{
  if(expression_reference_p(exp) &&
     reference_equal_p(gRefToReplace,
                       expression_reference(exp)))
    {
      free_normalized(expression_normalized(exp));
 
      expression_normalized(exp) = normalized_undefined;
 
      free_syntax(expression_syntax(exp));
 
      expression_syntax(exp) = expression_syntax(newExp);
 
      NORMALIZE_EXPRESSION(exp);
    }
}

References exp, expression_normalized, expression_reference(), expression_reference_p(), expression_syntax, free_normalized(), free_syntax(), gRefToReplace, NORMALIZE_EXPRESSION, normalized_undefined, and reference_equal_p().

Referenced by comEngine_replace_reference_in_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

create_realFifo_proc()

void create_realFifo_proc	(	statement	stat,
		list	lRef
	)

Parameters

stat	tat
lRef	Ref

Definition at line 1210 of file comEngine_generate_procCode.c.

{
  list lDone = NIL;
 
  pips_assert("true", stat==stat);
 
  //bool readAndWrite = false;
 
  MAP(REFERENCE, curRef1,
  {
    bool bDone = false;
 
    MAP(REFERENCE, refDone,
    {
      if(reference_equal_p(curRef1, refDone))
        {
          hash_put(gRefToFifoOff, hash_get(gRefToFifo, refDone), (void *)3);
          bDone = true;
          break;
        }
    }, lDone);
 
    if(bDone)
      continue;
 
    void* fifoNum = hash_get(gRefToFifo, curRef1);
 
    pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
                fifoNum != HASH_UNDEFINED_VALUE);
 
    hash_put(gRefToFifoOff, fifoNum, (void *)2);
 
    MAP(REFERENCE, curRef2,
    {
      if(reference_equal_p(curRef1, curRef2))
        {
          string effAction1 = hash_get(gRefToEff, curRef1);
 
          pips_assert("effAction1 != HASH_UNDEFINED_VALUE",
                      effAction1 != HASH_UNDEFINED_VALUE);
 
          string effAction2 = hash_get(gRefToEff, curRef2);
 
          pips_assert("effAction2 != HASH_UNDEFINED_VALUE",
                      effAction2 != HASH_UNDEFINED_VALUE);
 
          if(strcmp(effAction1, effAction2))
            {
              hash_put(gRefToFifoOff, fifoNum, (void *)3);
 
              lDone = CONS(REFERENCE, curRef1, lDone);
 
              break;
            }
        }
    }, lRef);
  }, lRef);
 
  gen_free_list(lDone);
 
  printf("create_realFifo_proc\n");
  MAP(REFERENCE, curRef,
  {
    printf("create_realFifo_proc it\n");
    print_reference(curRef);printf("\n");
    intptr_t fifoNum = (intptr_t)hash_get(gRefToFifo, curRef);
 
    pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
                fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
    get_realFifoNum(fifoNum);
  }, lRef);
 
  printf("create_realFifo_proc end\n");
}

References CONS, gen_free_list(), get_realFifoNum(), gRefToEff, gRefToFifo, gRefToFifoOff, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, intptr_t, MAP, NIL, pips_assert, print_reference(), printf(), REFERENCE, and reference_equal_p().

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

find_or_create_slot()

static int find_or_create_slot ( entity  ent )

static

Definition at line 685 of file comEngine_generate_procCode.c.

{
  intptr_t fifoNum = (intptr_t)hash_get(gEntToHREFifo, ent);
 
  if(fifoNum == (intptr_t)HASH_UNDEFINED_VALUE)
    {
      fifoNum = alloc_new_slot(ent);
    }
 
  return fifoNum;
}

References alloc_new_slot(), gEntToHREFifo, hash_get(), HASH_UNDEFINED_VALUE, and intptr_t.

Referenced by make_init_newInd_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_code_test_proc()

statement generate_code_test_proc

(

statement

stat

)

Parameters

stat

tat

Definition at line 1142 of file comEngine_generate_procCode.c.

{
  printf("generate_code_test\n");
  print_statement(stat);printf("\n");
  statement newStat = statement_undefined;
 
  newStat = get_call_stat_proc(stat);
 
  list lRef = hash_get(gStatToRef, stat);
 
  if(lRef != HASH_UNDEFINED_VALUE)
    {
      newStat = generate_stat_from_ref_list_proc(lRef, NIL, newStat);
    }
 
  // Get the new statements for the true statement
  statement trueStat = generate_code_function(test_true(statement_test(stat)), false);
 
  // Get the new statements for the false statement
  statement falseStat = generate_code_function(test_false(statement_test(stat)), false);
 
  list lStats = NIL;
 
  if(newStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, newStat, NIL));
    }
 
  if(trueStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, trueStat, NIL));
    }
 
  if(falseStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, falseStat, NIL));
    }
 
  newStat = make_block_statement(lStats);
 
  return newStat;
}

References CONS, gen_nconc(), generate_code_function(), generate_stat_from_ref_list_proc(), get_call_stat_proc(), gStatToRef, hash_get(), HASH_UNDEFINED_VALUE, make_block_statement(), NIL, print_statement(), printf(), STATEMENT, statement_test(), statement_undefined, test_false, and test_true.

Referenced by generate_code_function().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_mmcd_stat_from_ref()

static statement generate_mmcd_stat_from_ref ( reference  curRef, int  offset, expression  count, bool  bRead, list  lToggleEnt  )

static

Definition at line 402 of file comEngine_generate_procCode.c.

{
  statement newStat = statement_undefined;
 
  string name = NULL;
 
  intptr_t fifoNum = (intptr_t)hash_get(gRefToFifo, curRef);
 
  pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
              fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
  // Get the fifo number
  int realFifoNum = get_realFifoNum(fifoNum);
 
  expression hreBuff = expression_undefined;
 
  // If the toggle entity list is NIL, then realFifoNum is 
  // the fifo Number to use
  if(lToggleEnt == NIL)
    {
      hreBuff = int_to_expression(realFifoNum);
    }
  // else, ...
  else
    {
      printf("generate_mmcd_stat_from_ref 1\n");
      print_reference(curRef);printf("\n");
 
      // Get the toggle entity
      entity toggleEnt = get_toggleEnt_from_ref(curRef, lToggleEnt);
 
      list addArg = gen_make_list(expression_domain,
                                  int_to_expression(realFifoNum),
                                  entity_to_expression(toggleEnt),
                                  NULL);
 
      // Add the toggle entity and the fifo number
      hreBuff =
        call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                     addArg));
    }
 
  if(bRead)
    {
      name = strdup(GEN_LOAD_MMCD);
    }
  else
    {
      name = strdup(GEN_STORE_MMCD);
    }
 
  // Generate the statement
  newStat =
    make_mmcd_load_store_stat(name, hreBuff,
                              reference_to_expression(copy_reference(curRef)),
                              int_to_expression(offset), count);
 
  return newStat;
}

References call_to_expression(), copy_reference(), count, entity_intrinsic(), entity_to_expression(), expression_domain, expression_undefined, GEN_LOAD_MMCD, gen_make_list(), GEN_STORE_MMCD, get_realFifoNum(), get_toggleEnt_from_ref(), gRefToFifo, hash_get(), HASH_UNDEFINED_VALUE, int_to_expression(), intptr_t, make_call(), make_mmcd_load_store_stat(), NIL, offset, pips_assert, PLUS_OPERATOR_NAME, print_reference(), printf(), reference_to_expression(), statement_undefined, and strdup().

Referenced by generate_mmcd_stats_from_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_mmcd_stats_from_ref()

static void generate_mmcd_stats_from_ref ( list  lRef, hash_table  htOffset, expression  count, list  lToggleEnt, list *  lReadStats, list *  lWriteStats  )

static

Definition at line 468 of file comEngine_generate_procCode.c.

{
  list lReadDone = NIL;
  list lWriteDone = NIL;
 
  intptr_t offset = 0;
 
  MAP(REFERENCE, curRef,
  {
    if(htOffset != NULL)
      {
        offset = (intptr_t)hash_get(htOffset, curRef);
 
        pips_assert("ref offset undefined", offset != (intptr_t) HASH_UNDEFINED_VALUE);
      }
    else
      {
        offset = 1;
      }
 
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    //printf("mmcd ref\n");
    //print_reference(curRef);printf("\n");
 
    if(!strcmp(effAction, R_EFFECT))
      {
        //printf("read eff\n");
 
        statement readStat = generate_mmcd_stat_from_ref(curRef, offset,
                                                         count, true,
                                                         lToggleEnt);
 
        //print_statement(readStat);
 
        *lReadStats = gen_nconc(*lReadStats, CONS(STATEMENT, readStat, NIL));
 
        lReadDone = gen_nconc(lReadDone, CONS(REFERENCE, curRef, NIL));
      }
    else
      {
        //printf("write eff\n");
 
        statement writeStat = generate_mmcd_stat_from_ref(curRef, offset,
                                                          count, false,
                                                          lToggleEnt);
 
        //print_statement(writeStat);
 
        *lWriteStats = gen_nconc(*lWriteStats, CONS(STATEMENT, writeStat, NIL));
 
        lWriteDone = gen_nconc(lWriteDone, CONS(REFERENCE, curRef, NIL));
      }
 
  }, lRef);
 
  gen_free_list(lReadDone);
  gen_free_list(lWriteDone);
}

References CONS, count, gen_free_list(), gen_nconc(), generate_mmcd_stat_from_ref(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, MAP, NIL, offset, pips_assert, R_EFFECT, REFERENCE, and STATEMENT.

Referenced by generate_stat_from_ref_list_proc(), generate_stat_from_ref_list_proc_list(), and make_mmcd_stats_from_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_proc()

statement generate_stat_from_ref_list_proc	(	list	lRef,
		list	lToggleEnt,
		statement	stat
	)

Parameters

lRef	Ref
lToggleEnt	ToggleEnt
stat	tat

Definition at line 989 of file comEngine_generate_procCode.c.

{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
 
  generate_mmcd_stats_from_ref(lRef, NULL,
                               int_to_expression(1),
                               lToggleEnt,
                               &lReadStats, &lWriteStats);
 
  statement stepStat1 = make_step_inc_statement(1);
  statement stepStat2 = make_step_inc_statement(2);
 
  lStats = gen_nconc(CONS(STATEMENT, stepStat1, NIL), lReadStats);
  if(stat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stat, NIL));
    }
  lStats = gen_nconc(lStats, lWriteStats);
 
  if(lWriteStats != NIL)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat2, NIL));
    }
 
  return make_block_statement(lStats);
}

References CONS, gen_nconc(), generate_mmcd_stats_from_ref(), int_to_expression(), make_block_statement(), make_step_inc_statement(), NIL, STATEMENT, and statement_undefined.

Referenced by generate_code_call(), generate_code_loop(), generate_code_test_proc(), process_code_seq(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_proc_list()

list generate_stat_from_ref_list_proc_list	(	list	lRef,
		list	lInStats
	)

Parameters

lRef	Ref
lInStats	InStats

Definition at line 1025 of file comEngine_generate_procCode.c.

{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
 
  generate_mmcd_stats_from_ref(lRef, NULL,
                               int_to_expression(1),
                               NIL,
                               &lReadStats, &lWriteStats);
 
  statement stepStat1 = make_step_inc_statement(1);
  statement stepStat2 = make_step_inc_statement(2);
 
  lStats = gen_nconc(CONS(STATEMENT, stepStat1, NIL), lReadStats);
 
  lStats = gen_nconc(lStats, lInStats);
 
  lStats = gen_nconc(lStats, lWriteStats);
 
  if(lWriteStats != NIL)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat2, NIL));
    }
 
  return lStats;
}

References CONS, gen_nconc(), generate_mmcd_stats_from_ref(), int_to_expression(), make_step_inc_statement(), NIL, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

get_call_stat_proc()

statement get_call_stat_proc

(

_UNUSED_ statement

stat

)

Definition at line 1109 of file comEngine_generate_procCode.c.

{
  return statement_undefined;
}

References statement_undefined.

Referenced by generate_code_call(), and generate_code_test_proc().

Here is the caller graph for this function:

get_final_offset()

static bool get_final_offset ( list  lRefDim, intptr_t  offset, int  rank, intptr_t *  retVal  )

static

Definition at line 86 of file comEngine_generate_procCode.c.

{
  bool fort_org = get_bool_property("SIMD_FORTRAN_MEM_ORGANISATION");
 
  int i = 0;
  int ind;
 
  intptr_t finalOffset = 1;
 
  for(i = 0; i < (int) gen_length(lRefDim); i++)
    {
      if(fort_org)
        {
          ind = i;
        }
      else
        {
          ind = gen_length(lRefDim) - i - 1;
        }
 
      if(ind == rank)
        {
          break;
        }
 
      dimension curDim = DIMENSION(gen_nth(ind, lRefDim));
 
      expression lowerExp = dimension_lower(curDim);
      expression upperExp = dimension_upper(curDim);
 
      if(!integer_constant_expression_p(lowerExp) ||
         !integer_constant_expression_p(upperExp))
        {
          return false;
        }
 
      int lower = integer_constant_expression_value(lowerExp);
      int upper = integer_constant_expression_value(upperExp);
 
      pips_assert("lower < upper", lower < upper);
 
      finalOffset = finalOffset * (upper - lower + 1);
    }
 
  *retVal = finalOffset * offset;
 
  return true;
}

References DIMENSION, dimension_lower, dimension_upper, gen_length(), gen_nth(), get_bool_property(), int, integer_constant_expression_p(), integer_constant_expression_value(), intptr_t, offset, pips_assert, and rank.

Referenced by supported_ref_p().

Here is the call graph for this function:

Here is the caller graph for this function:

get_realFifoNum()

static intptr_t get_realFifoNum ( intptr_t  fifoNum )

static

Definition at line 274 of file comEngine_generate_procCode.c.

{
  static intptr_t gCurFifoCounter = 1;
 
  //printf("get_realFifoNum %d\n", fifoNum);
 
  // fifoNum value can be -1, if we want to increment
  // gCurFifoCounter with 1
  if(fifoNum < 0)
    {
      intptr_t newFifoNum = gCurFifoCounter;
 
      gCurFifoCounter += 1;
 
      return newFifoNum;
    }
 
  intptr_t realFifoNum = (intptr_t)hash_get(gRealFifo, (void *)fifoNum);
 
  // If no realFifoNum was associated with fifoNum,
  // then create a new realFifoNum
  if(realFifoNum == (intptr_t)HASH_UNDEFINED_VALUE)
    {
      realFifoNum = gCurFifoCounter;
 
      hash_put(gRealFifo, (void *)fifoNum, (void *)realFifoNum);
 
      HASH_MAP(ref1, fifo1,
      {
        if((intptr_t)fifo1 == (intptr_t)fifoNum)
          {
            hash_put(gRefToHREFifo, ref1, (void *)realFifoNum);
          }
      }, gOldRefToHREFifo);
 
      // Get the number of fifo that has to be allocated for this
      // realFifoNum
      intptr_t inc = (intptr_t)hash_get(gRefToFifoOff, (void *)fifoNum);
 
      if(inc == (intptr_t)HASH_UNDEFINED_VALUE)
        {
          inc = 1;
        }
 
      gCurFifoCounter += inc;
    }
 
  return realFifoNum;
}

References gOldRefToHREFifo, gRealFifo, gRefToFifoOff, gRefToHREFifo, hash_get(), HASH_MAP, hash_put(), HASH_UNDEFINED_VALUE, and intptr_t.

Referenced by alloc_new_slot(), create_realFifo_proc(), and generate_mmcd_stat_from_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

get_supportedRef_proc()

void get_supportedRef_proc	(	statement	stat,
		hash_table	htOffset,
		list *	lSupportedRef,
		list *	lUnSupportedRef
	)

Parameters

stat	tat
htOffset	tOffset
lSupportedRef	SupportedRef
lUnSupportedRef	UnSupportedRef

Definition at line 1077 of file comEngine_generate_procCode.c.

{
  loop curLoop = statement_loop(stat);
 
  list lRef = hash_get(gLoopToRef, stat);
 
  if(lRef == HASH_UNDEFINED_VALUE)
    {
      lRef = NIL;
    }
 
  MAP(REFERENCE, curRef,
  {
    //printf("loop ref\n");
    //print_reference(curRef);printf("\n");
 
    if(supported_ref_p(curRef, loop_index(curLoop), htOffset))
      {
        *lSupportedRef = gen_nconc(*lSupportedRef, CONS(REFERENCE, curRef, NIL));
      }
    else
      {
        *lUnSupportedRef = gen_nconc(*lUnSupportedRef, CONS(REFERENCE, curRef, NIL));
      }
 
  }, lRef);
 
  hash_put(gLoopToSupRef, stat, *lSupportedRef);
  hash_put(gLoopToUnSupRef, stat, *lUnSupportedRef);
}

References CONS, gen_nconc(), gLoopToRef, gLoopToSupRef, gLoopToUnSupRef, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, loop_index, MAP, NIL, REFERENCE, statement_loop(), and supported_ref_p().

Referenced by do_HRE_memory_mapping_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

get_toggleEnt_from_ref()

static entity get_toggleEnt_from_ref ( reference  curRef, list  lToggleEnt  )

static

Definition at line 327 of file comEngine_generate_procCode.c.

{
  void* fifoNum = hash_get(gRefToFifo, curRef);
 
  pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
              fifoNum != HASH_UNDEFINED_VALUE);
 
  intptr_t numOfFifo = (intptr_t)hash_get(gRefToFifoOff, fifoNum);
 
  pips_assert("(numOfFifo == 2) || (numOfFifo == 3)",
              (numOfFifo == 2) || (numOfFifo == 3));
 
  entity toggleEnt = entity_undefined;
 
  MAP(ENTITY, curEnt,
  {
    intptr_t curInc = (intptr_t)hash_get(gToggleToInc, curEnt);
 
    if(curInc == numOfFifo)
      {
        toggleEnt = curEnt;
        break;
      }
 
  }, lToggleEnt);
 
  pips_assert("toggleEnt != entity_undefined",
              toggleEnt != entity_undefined);
 
  return toggleEnt;
}

References ENTITY, entity_undefined, gRefToFifo, gRefToFifoOff, gToggleToInc, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, MAP, and pips_assert.

Referenced by generate_mmcd_stat_from_ref(), and make_mmcd_stats_from_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

has_call_stat_inside()

bool has_call_stat_inside

(

statement

stat

)

comEngine_generate_procCode.c

Parameters

stat

tat

Definition at line 260 of file comEngine_generate_procCode.c.

{
  bool bHasCallStat = false;
 
  gen_context_recurse(stat, &bHasCallStat, statement_domain,
                      has_call_stat_inside_flt, has_call_stat_inside_rwt);
 
  return bHasCallStat;
}

References gen_context_recurse, has_call_stat_inside_flt(), has_call_stat_inside_rwt(), and statement_domain.

Here is the call graph for this function:

has_call_stat_inside_flt()

static bool has_call_stat_inside_flt ( statement  stat, bool *  bHasCallStat  )

static

Definition at line 213 of file comEngine_generate_procCode.c.

{
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_loop:
    case is_instruction_forloop:
    case is_instruction_whileloop:
      {
        return false;
        break;
      }
 
    case is_instruction_sequence:
    case is_instruction_test:
      {
        return true;
        break;
      }
    case is_instruction_call:
      {
        *bHasCallStat = true;
        break;
      }
    default:
      {
        pips_internal_error("unsupported tag");
        break;
      }
    }
 
  return false;
}

References instruction_tag, is_instruction_call, is_instruction_forloop, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_whileloop, pips_internal_error, and statement_instruction.

Referenced by has_call_stat_inside().

Here is the caller graph for this function:

has_call_stat_inside_rwt()

static void has_call_stat_inside_rwt ( _UNUSED_ statement  stat, _UNUSED_ bool *  bHasCallStat  )

static

Definition at line 251 of file comEngine_generate_procCode.c.

{
}

Referenced by has_call_stat_inside().

Here is the caller graph for this function:

has_loop_inside()

static bool has_loop_inside ( statement  stat )

static

Definition at line 632 of file comEngine_generate_procCode.c.

{
  bool bHasLoop = false;
 
  gen_context_recurse(stat, &bHasLoop,
    statement_domain, has_loop_inside_flt, gen_null2);
 
  return bHasLoop;
}

References gen_context_recurse, gen_null2(), has_loop_inside_flt(), and statement_domain.

Referenced by make_init_newInd_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

has_loop_inside_flt()

static bool has_loop_inside_flt ( statement  stat, bool *  bHasLoop  )

static

Definition at line 594 of file comEngine_generate_procCode.c.

{
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_loop:
    case is_instruction_forloop:
    case is_instruction_whileloop:
      {
        *bHasLoop = true;
        return false;
        break;
      }
 
    case is_instruction_sequence:
    case is_instruction_test:
      {
        return true;
        break;
      }
    case is_instruction_call:
      {
        break;
      }
    default:
      {
        pips_internal_error("unsupported tag");
        break;
      }
    }
 
  return false;
}

References instruction_tag, is_instruction_call, is_instruction_forloop, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_whileloop, pips_internal_error, and statement_instruction.

Referenced by has_loop_inside().

Here is the caller graph for this function:

make_exec_mmcd()

statement make_exec_mmcd

(

void

)

Definition at line 967 of file comEngine_generate_procCode.c.

{
  static int number = 0;
 
  list arg = gen_make_list(expression_domain,
                           entity_to_expression(gStepEnt),
                           int_to_expression(number++),
                           NULL);
 
  statement mmcdStat =
    call_to_statement(
                      make_call(module_name_to_runtime_entity(strdup("GEN_EXEC_MMCD")),
                                arg));
 
  return mmcdStat;
}

References call_to_statement, entity_to_expression(), expression_domain, gen_make_list(), gStepEnt, int_to_expression(), make_call(), module_name_to_runtime_entity(), and strdup().

Referenced by add_exec_mmcd().

Here is the call graph for this function:

Here is the caller graph for this function:

make_init_newInd_stat()

statement make_init_newInd_stat	(	statement	stat,
		entity	newInd
	)

Parameters

stat	tat
newInd	ewInd

Definition at line 701 of file comEngine_generate_procCode.c.

{
  //printf("make_init_newInd_stat beg\n");
 
  list lUnSupportedRef = hash_get(gLoopToUnSupRef, stat);
 
  pips_assert("lUnSupportedRef != HASH_UNDEFINED_VALUE",
              lUnSupportedRef != HASH_UNDEFINED_VALUE);
 
  if((!has_loop_inside(loop_body(statement_loop(stat)))) &&
     (lUnSupportedRef == NIL))
    {
      return statement_undefined;
    }
 
  int fifoNum = find_or_create_slot(loop_index(statement_loop(stat)));
 
  statement newStat =
    make_mmcd_load_store_stat(strdup(GEN_LOAD_MMCD),
                              int_to_expression(fifoNum),
                              entity_to_expression(newInd),
                              int_to_expression(1),
                              int_to_expression(1));
 
  //printf("make_init_newInd_stat end\n");
  return newStat;
}

References entity_to_expression(), find_or_create_slot(), GEN_LOAD_MMCD, gLoopToUnSupRef, has_loop_inside(), hash_get(), HASH_UNDEFINED_VALUE, int_to_expression(), loop_body, loop_index, make_mmcd_load_store_stat(), NIL, pips_assert, statement_loop(), statement_undefined, and strdup().

Referenced by add_toggle_inc_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

make_loop_lStats_proc()

list make_loop_lStats_proc	(	statement	stat,
		entity	transferSize,
		statement	innerStat,
		entity	newOuterInd,
		list	lSupportedRef,
		hash_table	htOffset,
		expression	bufferSizeExp
	)

Parameters

stat	tat
transferSize	ransferSize
innerStat	nnerStat
newOuterInd	ewOuterInd
lSupportedRef	SupportedRef
htOffset	tOffset
bufferSizeExp	ufferSizeExp

Definition at line 1114 of file comEngine_generate_procCode.c.

{
  return make_lStats(stat, transferSize,
                     innerStat, newOuterInd,
                     lSupportedRef, htOffset,
                     bufferSizeExp);
}

References make_lStats().

Referenced by make_loopStat1().

Here is the call graph for this function:

Here is the caller graph for this function:

make_loop_step_stat()

statement make_loop_step_stat	(	statement	stat,
		entity	newOuterInd
	)

Parameters

stat	tat
newOuterInd	ewOuterInd

Definition at line 554 of file comEngine_generate_procCode.c.

{
  loop curLoop = statement_loop(stat);
 
  statement stepStat;
 
  if(gGenHRE)
    {
      stepStat = make_wait_step_statement();
    }
  else
    {
      stepStat = make_step_inc_statement(1);
    }
 
  list neArg = gen_make_list(expression_domain,
                             entity_to_expression(newOuterInd),
                             copy_expression(range_lower(loop_range(curLoop))),
                             NULL);
 
  expression neExp = 
    call_to_expression(make_call(entity_intrinsic(C_GREATER_THAN_OPERATOR_NAME),
                                 neArg));
 
  test t = make_test(neExp, stepStat, make_empty_statement());
 
  stepStat = make_statement(entity_empty_label(), 
                            STATEMENT_NUMBER_UNDEFINED,
                            STATEMENT_ORDERING_UNDEFINED,
                            empty_comments,
                            make_instruction(is_instruction_test, t),
                            NIL,NULL,
                            empty_extensions (), make_synchronization_none());
 
  return stepStat;
}

References C_GREATER_THAN_OPERATOR_NAME, call_to_expression(), copy_expression(), empty_comments, empty_extensions(), entity_empty_label(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), gGenHRE, is_instruction_test, loop_range, make_call(), make_empty_statement, make_instruction(), make_statement(), make_step_inc_statement(), make_synchronization_none(), make_test(), make_wait_step_statement(), NIL, range_lower, statement_loop(), STATEMENT_NUMBER_UNDEFINED, and STATEMENT_ORDERING_UNDEFINED.

Here is the call graph for this function:

make_lStats()

static list make_lStats ( statement  stat, entity  transferSize, statement  innerStat, entity  newOuterInd, list  lSupportedRef, hash_table  htOffset, expression  bufferSizeExp  )

static

Definition at line 942 of file comEngine_generate_procCode.c.

{
  list lStats = NIL;
 
  statement transStat = make_transStat(stat, newOuterInd,
                                       transferSize, bufferSizeExp);
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, transStat, NIL));
 
  list lTemp = NIL;
 
  lTemp = make_mmcd_stats_from_ref(stat, lSupportedRef, htOffset,
                                   transferSize, newOuterInd, innerStat);
 
  lStats = gen_nconc(lStats, lTemp);
 
  return lStats;
}

References CONS, gen_nconc(), make_mmcd_stats_from_ref(), make_transStat(), NIL, and STATEMENT.

Referenced by make_loop_lStats_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

make_mmcd_load_store_stat()

static statement make_mmcd_load_store_stat ( string  name, expression  hreBuff, expression  refExp, expression  offExp, expression  countExp  )

static

Definition at line 359 of file comEngine_generate_procCode.c.

{
  expression stepExp;
 
  if(!strcmp(name, GEN_STORE_MMCD))
    {
      list addArg = gen_make_list(expression_domain,
                                  entity_to_expression(gStepEnt),
                                  int_to_expression(1),
                                  NULL);
 
      stepExp =
        call_to_expression(make_call(entity_intrinsic(PLUS_C_OPERATOR_NAME),
                                     addArg));
    }
  else
    {
      stepExp = entity_to_expression(gStepEnt);
    }
 
  list arg = gen_make_list(expression_domain,
                           stepExp,
                           hreBuff,
                           refExp,
                           offExp,
                           countExp,
                           NULL);
 
  statement newStat =
    call_to_statement(make_call(module_name_to_runtime_entity(name),
                                arg));
 
  return newStat;
}

References call_to_expression(), call_to_statement, entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), GEN_STORE_MMCD, gStepEnt, int_to_expression(), make_call(), module_name_to_runtime_entity(), and PLUS_C_OPERATOR_NAME.

Referenced by generate_mmcd_stat_from_ref(), make_init_newInd_stat(), and make_toggle_mmcd().

Here is the call graph for this function:

Here is the caller graph for this function:

make_mmcd_stats_from_ref()

static list make_mmcd_stats_from_ref ( statement  stat, list  lSupportedRef, hash_table  htOffset, entity  transferSize, entity  newOuterInd, statement  innerStat  )

static

Definition at line 884 of file comEngine_generate_procCode.c.

{
  loop curLoop = statement_loop(stat);
 
  list lStats = NIL;
 
  list lSupReadStats = NIL;
  list lSupWriteStats = NIL;
 
  list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
 
  pips_assert("lToggleEnt != HASH_UNDEFINED_VALUE",
              lToggleEnt != HASH_UNDEFINED_VALUE);
 
  generate_mmcd_stats_from_ref(lSupportedRef, htOffset,
                               entity_to_expression(transferSize), lToggleEnt,
                               &lSupReadStats, &lSupWriteStats);
 
  MAP(REFERENCE, curRef,
  {
    hash_put(gRefToInd, curRef, loop_index(statement_loop(stat)));
  }, lSupportedRef);
 
  MAP(REFERENCE, curRef,
  {
    entity toggleEnt = get_toggleEnt_from_ref(curRef, lToggleEnt);
 
    hash_put(gRefToToggle, curRef, toggleEnt);
 
  }, lSupportedRef);
 
  MAP(STATEMENT, curStat,
  {
    comEngine_replace_reference_in_stat(curStat,
                              make_reference(loop_index(curLoop), NIL),
                              entity_to_expression(newOuterInd));
  }, lSupReadStats);
 
  MAP(STATEMENT, curStat,
  {
    comEngine_replace_reference_in_stat(curStat,
                              make_reference(loop_index(curLoop), NIL),
                              entity_to_expression(newOuterInd));
  }, lSupWriteStats);
 
  lStats = gen_nconc(lStats, lSupReadStats);
 
  if(innerStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, innerStat, NIL));
    }
 
  lStats = gen_nconc(lStats, lSupWriteStats);
 
  return lStats;
}

References comEngine_replace_reference_in_stat(), CONS, entity_to_expression(), gen_nconc(), generate_mmcd_stats_from_ref(), get_toggleEnt_from_ref(), gLoopToToggleEnt, gRefToInd, gRefToToggle, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, loop_index, make_reference(), MAP, NIL, pips_assert, REFERENCE, STATEMENT, statement_loop(), and statement_undefined.

Referenced by make_lStats().

Here is the call graph for this function:

Here is the caller graph for this function:

make_step_inc_statement()

statement make_step_inc_statement

(

int

incNum

)

Parameters

incNum

ncNum

Definition at line 537 of file comEngine_generate_procCode.c.

{
  list addArg = gen_make_list(expression_domain,
                              entity_to_expression(gStepEnt),
                              int_to_expression(incNum),
                              NULL);
 
  expression rExp = call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                                 addArg));
 
  return make_assign_statement(entity_to_expression(gStepEnt), rExp);
}

References call_to_expression(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), gStepEnt, int_to_expression(), make_assign_statement(), make_call(), and PLUS_OPERATOR_NAME.

Referenced by add_exec_mmcd(), generate_code_call(), generate_stat_from_ref_list_proc(), generate_stat_from_ref_list_proc_list(), make_loop_step_stat(), and process_gLoopToSync_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

make_toggle_mmcd()

statement make_toggle_mmcd

(

entity

ent

)

Parameters

ent

nt

Definition at line 668 of file comEngine_generate_procCode.c.

{
  int fifoNum = alloc_new_slot(ent);
 
  statement newStat =
    make_mmcd_load_store_stat(strdup(GEN_LOAD_MMCD),
                              int_to_expression(fifoNum),
                              entity_to_expression(ent),
                              int_to_expression(1),
                              int_to_expression(1));
 
  return newStat;
}

References alloc_new_slot(), entity_to_expression(), GEN_LOAD_MMCD, int_to_expression(), make_mmcd_load_store_stat(), and strdup().

Referenced by add_toggle_inc_statements(), and regenerate_toggles().

Here is the call graph for this function:

Here is the caller graph for this function:

make_transStat()

statement make_transStat	(	statement	stat,
		entity	newOuterInd,
		entity	transferSize,
		expression	bufferSizeExp
	)

tatement stepStat = make_loop_step_stat(stat, newOuterInd);

newStat = make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL), CONS(STATEMENT, newStat, NIL)));

f(!gGenHRE) { statement indStat = make_init_newInd_stat(stat, newOuterInd);

if(indStat != statement_undefined) { newStat = make_block_statement(gen_nconc(CONS(STATEMENT, newStat, NIL), CONS(STATEMENT, indStat, NIL))); } }

Parameters

stat	tat
newOuterInd	ewOuterInd
transferSize	ransferSize
bufferSizeExp	ufferSizeExp

Definition at line 733 of file comEngine_generate_procCode.c.

{
  statement newStat = statement_undefined;
 
  loop curLoop = statement_loop(stat);
 
  list rgSizeArg1 = gen_make_list(expression_domain,
                                  copy_expression(range_upper(loop_range(curLoop))),
                                  copy_expression(bufferSizeExp),
                                  NULL);
 
  expression rgSizeExp1 = 
    call_to_expression(make_call(entity_intrinsic(DIVIDE_OPERATOR_NAME),
                                 rgSizeArg1));
 
 
  list arg2Arg = gen_make_list(expression_domain,
                               copy_expression(bufferSizeExp),
                               rgSizeExp1,
                               NULL);
 
  expression arg2 = call_to_expression(make_call(entity_intrinsic(MULTIPLY_OPERATOR_NAME),
                                                 arg2Arg));
 
  list leArg = gen_make_list(expression_domain,
                             arg2,
                             entity_to_expression(newOuterInd),
                             NULL);
 
  expression leExp = 
    call_to_expression(make_call(entity_intrinsic(C_LESS_OR_EQUAL_OPERATOR_NAME),
                                 leArg));
 
  list modArg = gen_make_list(expression_domain,
                              copy_expression(range_upper(loop_range(curLoop))),
                              copy_expression(bufferSizeExp),
                              NULL);
 
  expression modExp =
    call_to_expression(make_call(entity_intrinsic(C_MODULO_OPERATOR_NAME),
                                 modArg));
 
  list addArg = gen_make_list(expression_domain,
                              modExp,
                              int_to_expression(1),
                              NULL);
 
  expression addExp =
    call_to_expression(make_call(entity_intrinsic(PLUS_C_OPERATOR_NAME),
                                 addArg));
 
  statement trueStat = make_assign_statement(entity_to_expression(transferSize),
                                             addExp);
 
  statement falseStat = make_assign_statement(entity_to_expression(transferSize),
                                              copy_expression(bufferSizeExp));
 
  expression rgUpper = range_upper(loop_range(curLoop));
  intptr_t upVal = -1;
  intptr_t rate = -1;
  expression_integer_value(rgUpper, &upVal);
  expression_integer_value(bufferSizeExp, &rate);
 
  if((upVal != -1) &&
     (rate != -1) &&
     ((upVal+1)%rate == 0))
    {
      free_expression(leExp);
      free_statement(trueStat);
      newStat = falseStat;
    }
  else if((upVal+1) < rate)
    {
      free_expression(leExp);
      free_statement(falseStat);
      newStat = trueStat;
    }
  else
    {
      test t = make_test(leExp, trueStat, falseStat);
 
      newStat = make_statement(entity_empty_label(), 
                               STATEMENT_NUMBER_UNDEFINED,
                               STATEMENT_ORDERING_UNDEFINED,
                               empty_comments,
                               make_instruction(is_instruction_test, t),
                               NIL,NULL,
                               empty_extensions (), make_synchronization_none());
    }
 
  /*statement stepStat = make_loop_step_stat(stat, newOuterInd);
 
  newStat = make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL),
                                           CONS(STATEMENT, newStat, NIL)));
  */
  /*if(!gGenHRE)
    {
      statement indStat = make_init_newInd_stat(stat, newOuterInd);
 
      if(indStat != statement_undefined)
        {
          newStat =
            make_block_statement(gen_nconc(CONS(STATEMENT, newStat, NIL),
                                           CONS(STATEMENT, indStat, NIL)));
        }
    }
*/
  return newStat;
}

References C_LESS_OR_EQUAL_OPERATOR_NAME, C_MODULO_OPERATOR_NAME, call_to_expression(), copy_expression(), DIVIDE_OPERATOR_NAME, empty_comments, empty_extensions(), entity_empty_label(), entity_intrinsic(), entity_to_expression(), expression_domain, expression_integer_value(), free_expression(), free_statement(), gen_make_list(), int_to_expression(), intptr_t, is_instruction_test, loop_range, make_assign_statement(), make_call(), make_instruction(), make_statement(), make_synchronization_none(), make_test(), MULTIPLY_OPERATOR_NAME, NIL, PLUS_C_OPERATOR_NAME, range_upper, statement_loop(), STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, and statement_undefined.

Referenced by make_loop_lStats_HRE(), and make_lStats().

Here is the call graph for this function:

Here is the caller graph for this function:

process_gLoopToSync_proc()

list process_gLoopToSync_proc	(	statement	stat,
		list	lInStats
	)

Parameters

stat	tat
lInStats	InStats

Definition at line 1188 of file comEngine_generate_procCode.c.

{
  bool loopSync = (intptr_t)hash_get(gLoopToSync, stat);
 
  if(loopSync == (intptr_t)HASH_UNDEFINED_VALUE)
    {
      return lInStats;
    }
 
  statement stepStat = make_step_inc_statement(2);
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, lInStats);
  lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat, NIL));
 
  return lInStats;
}

References CONS, gen_nconc(), gLoopToSync, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, make_step_inc_statement(), NIL, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

process_innerStat1_proc()

void process_innerStat1_proc	(	statement	stat,
		entity	oldInd,
		entity	newOuterInd,
		entity	newInnerInd
	)

Parameters

stat	tat
oldInd	ldInd
newOuterInd	ewOuterInd
newInnerInd	ewInnerInd

Definition at line 1057 of file comEngine_generate_procCode.c.

{
  list addArg = gen_make_list(expression_domain,
                              entity_to_expression(newOuterInd),
                              entity_to_expression(newInnerInd),
                              NULL);
 
  expression arg2 = call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                                 addArg));
 
  comEngine_replace_reference_in_stat(stat,
                                      make_reference(oldInd, NIL),
                                      arg2);
}

References call_to_expression(), comEngine_replace_reference_in_stat(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), make_call(), make_reference(), NIL, and PLUS_OPERATOR_NAME.

Referenced by usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

supported_ref_p()

static bool supported_ref_p ( reference  ref, entity  index, hash_table  htOffset  )

static

Definition at line 139 of file comEngine_generate_procCode.c.

{
  bool success = true;
  int offset = 0;
  int rank = 0;
 
  //printf("supported_ref_p \n");
  //print_reference(ref);printf("\n");
 
  MAP(EXPRESSION, ind,
  {
    normalized norm = NORMALIZE_EXPRESSION(ind);
 
    list indRefList = NIL;
 
    if(normalized_linear_p(norm))
      {
        Pvecteur vect = normalized_linear(norm);
 
        int curOffset = vect_coeff((Variable) index, vect);
 
        if(curOffset != 0)
          {
            if(offset != 0)
              {
                success = false;
              }
 
            offset = curOffset;
          }
      }
    else
      {
        success = false;
      }
 
    if(offset == 0)
      {
        rank++;
      }
 
    gen_free_list(indRefList);
 
  }, reference_indices(ref));
 
  if(success)
    {
      type refType = entity_type(reference_variable(ref));
 
      pips_assert("ref type is not variable", type_variable_p(refType));
 
      list lRefDim = variable_dimensions(type_variable(refType));
 
      intptr_t finalOffset;
 
      if(!get_final_offset(lRefDim, offset, rank, &finalOffset))
        {
          return false;
        }
 
      //printf("finalOffset %d\n", finalOffset);
      //printf("\n");
 
      pips_assert("finalOffset > 0", (finalOffset > 0));
 
      hash_put(htOffset, ref, (void*)finalOffset);
    }
 
  return success;
}

References entity_type, EXPRESSION, gen_free_list(), get_final_offset(), hash_put(), intptr_t, MAP, NIL, norm(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, offset, pips_assert, rank, ref, reference_indices, reference_variable, type_variable, type_variable_p, variable_dimensions, and vect_coeff().

Referenced by get_supportedRef_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

gOldRefToHREFifo

hash_table gOldRefToHREFifo

static

Definition at line 77 of file comEngine_generate_procCode.c.

Referenced by comEngine_generate_procCode(), and get_realFifoNum().

gRealFifo

hash_table gRealFifo

static

Definition at line 68 of file comEngine_generate_procCode.c.

Referenced by comEngine_generate_procCode(), and get_realFifoNum().

gRefToReplace

reference gRefToReplace

static

Definition at line 844 of file comEngine_generate_procCode.c.

Referenced by comEngine_replace_reference_in_stat(), and comEngine_replace_reference_in_stat_rwt().

gStepEnt

entity gStepEnt

static

Definition at line 72 of file comEngine_generate_procCode.c.

Referenced by comEngine_generate_procCode(), make_exec_mmcd(), make_mmcd_load_store_stat(), and make_step_inc_statement().