comEngine_HRE_distribute.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 "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_HRE_distribute.c:

Go to the source code of this file.

Functions
static statement	HRE_distribute_stat (statement stat, bool calledFromLoop)
static void	generate_scalar_variables_from_list (list lRef)
static entity	find_or_create_newInd (entity ind, bool bIsInd)
static expression	get_indExp_from_ref (reference curRef, hash_table ht, bool *innerInd)
expression	get_fifoExp_from_ref (reference curRef, expression buffExp, hash_table ht)
	comEngine_HRE_distribute.c More...
static statement	make_read_write_fifo_stat (string name, expression fifoExp, expression indExp, expression hreBuffExp)
statement	generate_fifo_stat2 (reference curRef, bool bRead)
statement	generate_ind_fifo_stat2 (entity oldInd, entity newInd, bool bRead)
void	generate_fifo_stats2 (list lRef, list *lReadStats, list *lWriteStats)
static void	replace_array_ref_with_fifos2 (list lRef, statement *newStat)
static statement	add_index_statements (statement stat)
static statement	generate_code ()
static void	make_HRE_empty_module ()
static void	fill_HRE_module (statement stat)
static void	loop_enter ()
static statement	HRE_distribute_loop (statement stat)
static statement	HRE_distribute_call (statement stat)
static statement	HRE_distribute_seq (statement stat)
static statement	HRE_distribute_test (statement stat)
statement	HRE_distribute (statement stat, string new_module_name, const char *module_name)

Variables
static hash_table	gOldIndToNewInd
static hash_table	gIsIndex
static list	gCurStats = NIL
static list	glCurRep = NIL
static const char *	g_new_module_name = NULL
static const char *	g_module_name = NULL
static int	gIfCount = 0
static list	glCurLoop = NIL
static entity	gNewInd = entity_undefined
static list	glReadStats = NIL
static list	glWriteStats = NIL

Function Documentation

add_index_statements()

static statement add_index_statements ( statement  stat )

static

Definition at line 557 of file comEngine_HRE_distribute.c.

{
  list lReadStats = NIL;
  //list lWriteStats = NIL;
 
  HASH_MAP(oldInd, newInd,
  {
    if(newInd == gNewInd)
      {
        continue;
      }
 
    statement readStat = generate_ind_fifo_stat2(oldInd, newInd, true);
 
    lReadStats = CONS(STATEMENT, readStat, lReadStats);
 
    //statement writeStat = generate_ind_fifo_stat2(oldInd, newInd, false);
 
    //lWriteStats = CONS(STATEMENT, writeStat, lWriteStats);
 
  }, gOldIndToNewInd);
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, lReadStats);
  lStats = gen_nconc(lStats, glReadStats);
  lStats = gen_nconc(lStats, CONS(STATEMENT, stat, NIL));
  lStats = gen_nconc(lStats, glWriteStats);
  //lStats = gen_nconc(lStats, lWriteStats);
 
  return make_block_statement(lStats);
}

References CONS, gen_nconc(), generate_ind_fifo_stat2(), glReadStats, glWriteStats, gNewInd, gOldIndToNewInd, HASH_MAP, make_block_statement(), NIL, and STATEMENT.

Referenced by generate_code().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_HRE_module()

static void fill_HRE_module ( statement  stat )

static

Definition at line 686 of file comEngine_HRE_distribute.c.

{
  create_HRE_module(entity_local_name(get_current_module_entity()),
                    g_module_name, stat, get_current_module_entity());
}

References create_HRE_module(), entity_local_name(), g_module_name, and get_current_module_entity().

Referenced by loop_enter().

Here is the call graph for this function:

Here is the caller graph for this function:

find_or_create_newInd()

static entity find_or_create_newInd ( entity  ind, bool  bIsInd  )

static

Definition at line 168 of file comEngine_HRE_distribute.c.

{
  entity new_ent = entity_undefined;
 
  // If the entity was already created, then just return the existing
  // entity
  new_ent = hash_get(gOldIndToNewInd, ind);
 
  if(new_ent != HASH_UNDEFINED_VALUE)
    {
      return new_ent;
    }
 
  // Create a new entity
  new_ent =
    make_new_scalar_variable_with_prefix(entity_local_name(ind),
                                         get_current_module_entity(),
                                         copy_basic(entity_basic(ind)));
  AddEntityToCurrentModule(new_ent);
 
  statement loopStat = STATEMENT(CAR(glCurLoop));
 
  list lUnSupportedRef = hash_get(gLoopToUnSupRef, loopStat);
 
  pips_assert("lUnSupportedRef != HASH_UNDEFINED_VALUE",
              lUnSupportedRef != HASH_UNDEFINED_VALUE);
 
  // If the entity created is actually the index of 
  // the new loop, then do gNewInd = new_ent
  if((loop_index(statement_loop(loopStat)) == ind) &&
     (lUnSupportedRef == NIL))
    {
      gNewInd = new_ent;
    }
 
  // Memorize the creation of the entity
  hash_put(gOldIndToNewInd, ind, new_ent);
 
  // If the entity is an index, then memorize it with gIsIndex
  if(bIsInd)
    {
      hash_put(gIsIndex, new_ent, (void *)true);
    }
 
  return new_ent;
}

References AddEntityToCurrentModule(), CAR, copy_basic(), entity_basic(), entity_local_name(), entity_undefined, get_current_module_entity(), gIsIndex, glCurLoop, gLoopToUnSupRef, gNewInd, gOldIndToNewInd, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, loop_index, make_new_scalar_variable_with_prefix(), NIL, pips_assert, STATEMENT, and statement_loop().

Referenced by get_fifoExp_from_ref(), and get_indExp_from_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_code()

static statement generate_code ( )

static

rintf("glCurRep\n"); MAP(REFERENCE, curRef, { printf("glCurRep it\n"); print_reference(curRef);printf("\n"); }, glCurRep);

Definition at line 593 of file comEngine_HRE_distribute.c.

{
  if(gCurStats == NIL)
    {
      return make_block_statement(NIL);
    }
 
  printf("generate_code\n");
 
  generate_scalar_variables_from_list(glCurRep);
 
  /*printf("glCurRep\n");
  MAP(REFERENCE, curRef,
  {
    printf("glCurRep it\n");
    print_reference(curRef);printf("\n");
  }, glCurRep);
*/
  statement newStat = make_block_statement(gCurStats);
 
  printf("newStat bef\n");
  print_statement(newStat);
 
  replace_array_ref_with_fifos2(glCurRep, &newStat);
 
  printf("newStat aft 1\n");
  print_statement(newStat);
 
  if(gNewInd != entity_undefined)
    {
      loop curLoop = statement_loop(STATEMENT(CAR(glCurLoop)));
 
      loop newLoop = make_loop(gNewInd,
                               make_range(int_to_expression(0),
                                          copy_expression(gBufferSizeEnt),
                                          int_to_expression(1)),
                               newStat,
                               loop_label(curLoop),
                               make_execution(is_execution_sequential, UU),
                               NIL);
 
      newStat = make_statement(entity_empty_label(),
                               STATEMENT_NUMBER_UNDEFINED,
                               STATEMENT_ORDERING_UNDEFINED,
                               empty_comments,
                               make_instruction_loop(newLoop),NIL,NULL,
                               empty_extensions (), make_synchronization_none());
    }
 
  newStat = add_index_statements(newStat);
 
  // Reinitialize global variables
  glReadStats = NIL;
  glWriteStats = NIL;
 
  gen_free_list(glCurRep);
 
  gCurStats = NIL;
  glCurRep = NIL;
 
  hash_table_free(gOldIndToNewInd);
  gOldIndToNewInd = hash_table_make(hash_pointer, 0);
  gNewInd = entity_undefined;
 
  hash_table_free(gRefToHREVar);
  gRefToHREVar = hash_table_make(hash_pointer, 0);
 
  return newStat;
}

References add_index_statements(), CAR, copy_expression(), empty_comments, empty_extensions(), entity_empty_label(), entity_undefined, gBufferSizeEnt, gCurStats, gen_free_list(), generate_scalar_variables_from_list(), glCurLoop, glCurRep, glReadStats, glWriteStats, gNewInd, gOldIndToNewInd, gRefToHREVar, hash_pointer, hash_table_free(), hash_table_make(), int_to_expression(), is_execution_sequential, loop_label, make_block_statement(), make_execution(), make_instruction_loop(), make_loop(), make_range(), make_statement(), make_synchronization_none(), NIL, print_statement(), printf(), replace_array_ref_with_fifos2(), STATEMENT, statement_loop(), STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, and UU.

Referenced by loop_enter().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_fifo_stat2()

statement generate_fifo_stat2	(	reference	curRef,
		bool	bRead
	)

Parameters

curRef	urRef
bRead	Read

Definition at line 336 of file comEngine_HRE_distribute.c.

{
  statement newStat = statement_undefined;
 
  string name = NULL;
 
  expression buffExp = get_fifo_from_ref(curRef);
 
  //printf("generate_fifo_stat2\n");
  //print_reference(curRef);printf("\n");
 
  if(buffExp == expression_undefined)
    {
      return statement_undefined;
    }
 
  bool innerInd = false;
 
  expression indExp = get_indExp_from_ref(curRef, gRefToInd, &innerInd);
 
  expression fifoExp = get_fifoExp_from_ref(curRef, buffExp, gRefToToggle);
 
  entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
  pips_assert("hreBuffEnt != entity_undefined",
              hreBuffEnt != entity_undefined);
 
  if(bRead)
    {
      name = strdup(READ_FIFO);
    }
  else
    {
      name = strdup(WRITE_FIFO);
    }
 
  newStat = make_read_write_fifo_stat(name, fifoExp, indExp,
                                      entity_to_expression(hreBuffEnt));
 
  if(!innerInd)
    {
      if(bRead)
        {
          glReadStats = CONS(STATEMENT, newStat, glReadStats);
        }
      else
        {
          glWriteStats = CONS(STATEMENT, newStat, glWriteStats);
        }
 
      return statement_undefined;
    }
 
  return newStat;
}

References CONS, entity_to_expression(), entity_undefined, expression_undefined, get_fifo_from_ref(), get_fifoExp_from_ref(), get_HRE_buff_ent_from_ref(), get_indExp_from_ref(), glReadStats, glWriteStats, gRefToInd, gRefToToggle, make_read_write_fifo_stat(), pips_assert, READ_FIFO, STATEMENT, statement_undefined, strdup(), and WRITE_FIFO.

Referenced by generate_fifo_stats2().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_fifo_stats2()

void generate_fifo_stats2	(	list	lRef,
		list *	lReadStats,
		list *	lWriteStats
	)

Parameters

lRef	Ref
lReadStats	ReadStats
lWriteStats	WriteStats

Definition at line 432 of file comEngine_HRE_distribute.c.

{
  list lReadDone = NIL;
  list lWriteDone = NIL;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    //printf("fifo ref %d\n", (int)curRef);
    //print_reference(curRef);printf("\n");
 
    if(!strcmp(effAction, R_EFFECT))
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lReadDone);
 
        if(!alreadyDone)
          {
            //printf("read eff\n");
 
            lReadDone = gen_nconc(lReadDone, CONS(REFERENCE, curRef, NIL));
 
            statement readStat = generate_fifo_stat2(curRef, true);
 
            if(readStat == statement_undefined)
              {
                continue;
              }
 
            *lReadStats = gen_nconc(*lReadStats, CONS(STATEMENT, readStat, NIL));
            //print_statement(readStat);
          }
      }
    else
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lWriteDone);
 
        if(!alreadyDone)
          {
            //printf("write eff\n");
 
            lWriteDone = gen_nconc(lWriteDone, CONS(REFERENCE, curRef, NIL));
 
            statement writeStat = generate_fifo_stat2(curRef, false);
 
            if(writeStat == statement_undefined)
              {
                continue;
              }
 
            *lWriteStats = gen_nconc(*lWriteStats, CONS(STATEMENT, writeStat, NIL));
 
            //print_statement(writeStat);
          }
      }
 
  }, lRef);
 
  gen_free_list(lReadDone);
  gen_free_list(lWriteDone);
}

References CONS, gen_free_list(), gen_nconc(), generate_fifo_stat2(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, MAP, NIL, pips_assert, R_EFFECT, REFERENCE, reference_equal_p(), STATEMENT, and statement_undefined.

Referenced by replace_array_ref_with_fifos2().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_ind_fifo_stat2()

statement generate_ind_fifo_stat2	(	entity	oldInd,
		entity	newInd,
		bool	bRead
	)

Parameters

oldInd	ldInd
newInd	ewInd
bRead	Read

Definition at line 396 of file comEngine_HRE_distribute.c.

{
  statement newStat = statement_undefined;
 
  string name = NULL;
 
  intptr_t indNum = (intptr_t)hash_get(gIndToNum, oldInd);
 
  pips_assert("indNum != HASH_UNDEFINED_VALUE",
              indNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
  if(bRead)
    {
      name = strdup(READ_FIFO);
    }
  else
    {
      name = strdup(WRITE_FIFO);
    }
 
  intptr_t fifoNum = (intptr_t)hash_get(gEntToHREFifo, oldInd);
 
  pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
              fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
  newStat =
    make_read_write_fifo_stat(name,
                              int_to_expression(fifoNum),
                              int_to_expression(indNum),
                              entity_to_expression(newInd));
  return newStat;
}

References entity_to_expression(), gEntToHREFifo, gIndToNum, hash_get(), HASH_UNDEFINED_VALUE, int_to_expression(), intptr_t, make_read_write_fifo_stat(), pips_assert, READ_FIFO, statement_undefined, strdup(), and WRITE_FIFO.

Referenced by add_index_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_scalar_variables_from_list()

static void generate_scalar_variables_from_list ( list  lRef )

static

Definition at line 104 of file comEngine_HRE_distribute.c.

{
  MAP(REFERENCE, curRef,
  {
    bool alreadyDone = false;
    reference refFound = reference_undefined;
 
    HASH_MAP(ref1, var1,
    {
      if(reference_equal_p(curRef, ref1))
        {
          alreadyDone = true;
          refFound = ref1;
          break;
        }
    }, gRefToHREVar);
 
    if(!alreadyDone)
      {
        //printf("it\n");
        //print_reference(curRef);printf("\n");
 
        string name =
          strdup(entity_local_name(reference_variable((reference)curRef)));
 
        basic bas = basic_of_reference((reference)curRef);
 
        pips_assert("bas != basic_undefined", bas != basic_undefined);
 
        //entity new_ent = make_new_scalar_entity(name, copy_basic(bas));
 
        entity new_ent = make_new_scalar_variable_with_prefix(name,
                                                              get_current_module_entity(),
                                                              bas);
    AddEntityToCurrentModule(new_ent);
 
        //printf("%s\n", entity_user_name(new_ent));
 
        if(hash_get(gRefToHREVar, curRef) == HASH_UNDEFINED_VALUE)
          {
            hash_put(gRefToHREVar, curRef, new_ent);
          }
      }
    else
      {
        //printf("it found\n");
        //print_reference(curRef);printf("\n");
 
        entity scalEnt = hash_get(gRefToHREVar, refFound);
 
        if(hash_get(gRefToHREVar, curRef) == HASH_UNDEFINED_VALUE)
          {
            hash_put(gRefToHREVar, curRef, scalEnt);
          }
      }
 
  }, lRef);
 
}

References AddEntityToCurrentModule(), basic_of_reference(), basic_undefined, entity_local_name(), get_current_module_entity(), gRefToHREVar, hash_get(), HASH_MAP, hash_put(), HASH_UNDEFINED_VALUE, make_new_scalar_variable_with_prefix(), MAP, pips_assert, REFERENCE, reference_equal_p(), reference_undefined, reference_variable, and strdup().

Referenced by generate_code().

Here is the call graph for this function:

Here is the caller graph for this function:

get_fifoExp_from_ref()

expression get_fifoExp_from_ref	(	reference	curRef,
		expression	buffExp,
		hash_table	ht
	)

comEngine_HRE_distribute.c

Parameters

curRef	urRef
buffExp	uffExp
ht	t

Definition at line 260 of file comEngine_HRE_distribute.c.

{
  entity ind = entity_undefined;
 
  HASH_MAP(ref1, ind1,
  {
    if(reference_equal_p(curRef, ref1))
      {
        ind = ind1;
        break;
      }
  }, ht);
 
  expression fifoExp;
 
  if(ind == entity_undefined)
    {
      fifoExp = buffExp;
    }
  else
    {
      entity new_ent = find_or_create_newInd(ind, false);
 
      list addArg = gen_make_list(expression_domain,
                                  buffExp,
                                  entity_to_expression(new_ent),
                                  NULL);
 
      fifoExp =
        call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                     addArg));
    }
 
  return fifoExp;
}

References call_to_expression(), entity_intrinsic(), entity_to_expression(), entity_undefined, expression_domain, find_or_create_newInd(), gen_make_list(), HASH_MAP, make_call(), PLUS_OPERATOR_NAME, and reference_equal_p().

Referenced by generate_fifo_stat2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_indExp_from_ref()

static expression get_indExp_from_ref ( reference  curRef, hash_table  ht, bool *  innerInd  )

static

Definition at line 219 of file comEngine_HRE_distribute.c.

{
  entity ind = entity_undefined;
 
  HASH_MAP(ref1, ind1,
  {
    if(reference_equal_p(curRef, ref1))
      {
        ind = ind1;
        break;
      }
  }, ht);
 
  expression indExp;
 
  // If the index ind is undefined then let read from the 
  // beginning of the fifo
  if(ind == entity_undefined)
    {
      indExp = int_to_expression(0);
    }
  else
    {
      if(loop_index(statement_loop(STATEMENT(CAR(glCurLoop)))) == ind)
        {
          *innerInd = true;
        }
 
      entity new_ent = find_or_create_newInd(ind, true);
 
      indExp = entity_to_expression(new_ent);
    }
 
  return indExp;
}

References CAR, entity_to_expression(), entity_undefined, find_or_create_newInd(), glCurLoop, HASH_MAP, int_to_expression(), loop_index, reference_equal_p(), STATEMENT, and statement_loop().

Referenced by generate_fifo_stat2().

Here is the call graph for this function:

Here is the caller graph for this function:

HRE_distribute()

statement HRE_distribute	(	statement	stat,
		string	new_module_name,
		const char *	module_name
	)

Parameters

stat	tat
new_module_name	ew_module_name
module_name	odule_name

Definition at line 955 of file comEngine_HRE_distribute.c.

{
  printf("stat bef HRE_distribute\n");
  print_statement(stat);
 
  // Global variables initialization
  g_new_module_name = new_module_name;
  g_module_name = module_name;
  gCurStats = NIL;
  glCurRep = NIL;
  gIfCount = 0;
  glCurLoop = NIL;
  gNewInd = entity_undefined;
  gOldIndToNewInd = hash_table_make(hash_pointer, 0);
  gIsIndex = hash_table_make(hash_pointer, 0);
  glReadStats = NIL;
  glWriteStats = NIL;
 
  HRE_distribute_stat(stat, true);
 
  loop_enter();
 
  // Free some global variables
  hash_table_free(gOldIndToNewInd);
  hash_table_free(gIsIndex);
 
  return make_block_statement(NIL);
}

References entity_undefined, g_module_name, g_new_module_name, gCurStats, gIfCount, gIsIndex, glCurLoop, glCurRep, glReadStats, glWriteStats, gNewInd, gOldIndToNewInd, hash_pointer, hash_table_free(), hash_table_make(), HRE_distribute_stat(), loop_enter(), make_block_statement(), module_name(), NIL, print_statement(), and printf().

Referenced by comEngine_generate_HRECode().

Here is the call graph for this function:

Here is the caller graph for this function:

HRE_distribute_call()

static statement HRE_distribute_call ( statement  stat )

static

Definition at line 794 of file comEngine_HRE_distribute.c.

{
  statement newStat = statement_undefined;
 
  list lCallRef = NIL;
  call curCall = instruction_call(statement_instruction(stat));
 
  MAP(EXPRESSION, exp,
  {
    list old = lCallRef;
    list new = NIL;
    new = comEngine_expression_to_reference_list(exp, new);
 
    lCallRef = gen_concatenate(old, new);
 
    gen_free_list(old);
    gen_free_list(new);
 
  }, call_arguments(curCall));
 
  glCurRep = gen_nconc(glCurRep, lCallRef);
 
  if(gIfCount == 0)
    {
      newStat = copy_statement(stat);
 
      statement_comments(newStat) = string_undefined;
    }
 
  return newStat;
}

References call_arguments, comEngine_expression_to_reference_list(), copy_statement(), exp, EXPRESSION, gen_concatenate(), gen_free_list(), gen_nconc(), gIfCount, glCurRep, instruction_call, MAP, NIL, statement_comments, statement_instruction, statement_undefined, and string_undefined.

Referenced by HRE_distribute_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

HRE_distribute_loop()

static statement HRE_distribute_loop ( statement  stat )

static

Definition at line 771 of file comEngine_HRE_distribute.c.

{
  //printf("HRE_distribute_loop beg\n");
 
  loop_enter();
 
  glCurLoop = CONS(STATEMENT, stat, glCurLoop);
 
  HRE_distribute_stat(loop_body(statement_loop(stat)), true);
 
  loop_enter();
 
  gen_remove(&glCurLoop, stat);
 
  //create_loop_HRE_module();
 
  return statement_undefined;
}

References CONS, gen_remove(), glCurLoop, HRE_distribute_stat(), loop_body, loop_enter(), STATEMENT, statement_loop(), and statement_undefined.

Referenced by HRE_distribute_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

HRE_distribute_seq()

static statement HRE_distribute_seq ( statement  stat )

static

Definition at line 830 of file comEngine_HRE_distribute.c.

{
  instruction instr = statement_instruction(stat);
 
  //printf("HRE_distribute_seq\n");
  MAP(STATEMENT, curStat,
  {
    statement seqStat = HRE_distribute_stat(curStat, false);
 
    //printf("seqStat\n");
    if(seqStat == statement_undefined)
      {
        //printf("undefined\n");
      }
    else
      {
        //print_statement(seqStat);
        if(gIfCount == 0)
          {
            gCurStats = gen_nconc(gCurStats, CONS(STATEMENT, seqStat, NIL));
          }
      }
 
  }, sequence_statements(instruction_sequence(instr)));
 
  return statement_undefined;
}

References CONS, gCurStats, gen_nconc(), gIfCount, HRE_distribute_stat(), instruction_sequence, MAP, NIL, sequence_statements, STATEMENT, statement_instruction, and statement_undefined.

Referenced by HRE_distribute_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

HRE_distribute_stat()

static statement HRE_distribute_stat ( statement  stat, bool  calledFromLoop  )

static

Definition at line 897 of file comEngine_HRE_distribute.c.

{
  statement newStat = statement_undefined;
 
  printf("HRE_distribute_stat\n");
  print_statement(stat);
 
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_sequence:
      {
        newStat = HRE_distribute_seq(stat);
 
        break;
      }
    case is_instruction_loop:
      {
        newStat = HRE_distribute_loop(stat);
        break;
      }
    case is_instruction_call:
      {
        newStat = HRE_distribute_call(stat);
 
        if(calledFromLoop && (gIfCount == 0))
          {
            gCurStats = gen_nconc(gCurStats, CONS(STATEMENT, newStat, NIL));
          }
 
        break;
      }
    case is_instruction_test:
      {
        newStat = HRE_distribute_test(stat);
 
        if(calledFromLoop && (gIfCount == 0))
          {
            gCurStats = gen_nconc(gCurStats, CONS(STATEMENT, newStat, NIL));
          }
 
        break;
      }
    default:
      {
        pips_assert("FALSE", false);
        break;
      }
    }
  printf("HRE_distribute_stat end\n");
  return newStat;
}

References CONS, gCurStats, gen_nconc(), gIfCount, HRE_distribute_call(), HRE_distribute_loop(), HRE_distribute_seq(), HRE_distribute_test(), instruction_tag, is_instruction_call, is_instruction_loop, is_instruction_sequence, is_instruction_test, NIL, pips_assert, print_statement(), printf(), STATEMENT, statement_instruction, and statement_undefined.

Referenced by HRE_distribute(), HRE_distribute_loop(), HRE_distribute_seq(), and HRE_distribute_test().

Here is the call graph for this function:

Here is the caller graph for this function:

HRE_distribute_test()

static statement HRE_distribute_test ( statement  stat )

static

Definition at line 862 of file comEngine_HRE_distribute.c.

{
  statement newStat = statement_undefined;
 
  list lCond = NIL;
  lCond =
    comEngine_expression_to_reference_list(test_condition(statement_test(stat)),
                                           lCond);
 
  glCurRep = gen_nconc(glCurRep, lCond);
 
  gIfCount++;
 
  // Generate the HRE code for the true statement
  HRE_distribute_stat(test_true(statement_test(stat)), true);
 
  // Generate the HRE code for the false statement
  HRE_distribute_stat(test_false(statement_test(stat)), true);
 
  gIfCount--;
 
  if(gIfCount == 0)
    {
      newStat = copy_statement(stat);
 
      statement_comments(newStat) = string_undefined;
    }
 
  return newStat;
}

References comEngine_expression_to_reference_list(), copy_statement(), gen_nconc(), gIfCount, glCurRep, HRE_distribute_stat(), NIL, statement_comments, statement_test(), statement_undefined, string_undefined, test_condition, test_false, and test_true.

Referenced by HRE_distribute_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_enter()

static void loop_enter ( )

static

Definition at line 695 of file comEngine_HRE_distribute.c.

{
  if(gCurStats == NIL)
    {
      return;
    }
 
  make_HRE_empty_module();
 
  statement newStat = generate_code();
 
  fill_HRE_module(newStat);
}

References fill_HRE_module(), gCurStats, generate_code(), make_HRE_empty_module(), and NIL.

Referenced by HRE_distribute(), and HRE_distribute_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

make_HRE_empty_module()

static void make_HRE_empty_module ( )

static

Definition at line 666 of file comEngine_HRE_distribute.c.

{
  static int number = 0;
 
  string num  = int2a(number++);
  string prefix = strdup(concatenate(g_new_module_name,"_",
                                     num,
                                     (char *) NULL));
  free(num);
 
  entity new_fun = make_empty_subroutine(prefix,make_language_unknown());
 
  reset_current_module_entity();
 
  set_current_module_entity(new_fun);
}

References concatenate(), free(), g_new_module_name, int2a(), make_empty_subroutine(), make_language_unknown(), num, prefix, reset_current_module_entity(), set_current_module_entity(), and strdup().

Referenced by loop_enter().

Here is the call graph for this function:

Here is the caller graph for this function:

make_read_write_fifo_stat()

static statement make_read_write_fifo_stat ( string  name, expression  fifoExp, expression  indExp, expression  hreBuffExp  )

static

Definition at line 297 of file comEngine_HRE_distribute.c.

{
  statement newStat;
 
  if(!strcmp(name, READ_FIFO))
    {
      list arg = gen_make_list(expression_domain,
                               fifoExp,
                               indExp,
                               NULL);
 
      expression rExp = call_to_expression(make_call(module_name_to_runtime_entity(name), 
                                            arg));
 
      newStat = make_assign_statement(hreBuffExp, rExp);
    }
  else
    {
      list arg = gen_make_list(expression_domain,
                               fifoExp,
                               indExp,
                               hreBuffExp,
                               NULL);
 
      newStat = call_to_statement(
                                  make_call(module_name_to_runtime_entity(name), 
                                            arg));
    }
 
  return newStat;
}

References call_to_expression(), call_to_statement, expression_domain, gen_make_list(), make_assign_statement(), make_call(), module_name_to_runtime_entity(), and READ_FIFO.

Referenced by generate_fifo_stat2(), and generate_ind_fifo_stat2().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_array_ref_with_fifos2()

static void replace_array_ref_with_fifos2 ( list  lRef, statement *  newStat  )

static

Definition at line 519 of file comEngine_HRE_distribute.c.

{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
printf("replace_array_ref_with_fifos2\n");
  generate_fifo_stats2(lRef, &lReadStats, &lWriteStats);
printf("replace_array_ref_with_fifos2 1\n");
  FOREACH(REFERENCE, curRef,lRef)
  {
    printf("replace_array_ref %p\n", curRef);
    print_reference(curRef);printf("\n");
 
    entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
    pips_assert("hreBuffEnt != entity_undefined",
                hreBuffEnt != entity_undefined);
 
    reference hreBuffRef = make_reference(hreBuffEnt, NIL);
 
    comEngine_replace_reference_in_stat(*newStat, curRef, reference_to_expression(hreBuffRef));
 
  }
 
  lStats = lReadStats;
  if(*newStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, *newStat, NIL));
    }
  lStats = gen_nconc(lStats, lWriteStats);
 
  *newStat = make_block_statement(lStats);
}

References comEngine_replace_reference_in_stat(), CONS, entity_undefined, FOREACH, gen_nconc(), generate_fifo_stats2(), get_HRE_buff_ent_from_ref(), make_block_statement(), make_reference(), NIL, pips_assert, print_reference(), printf(), REFERENCE, reference_to_expression(), STATEMENT, and statement_undefined.

Referenced by generate_code().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_module_name

const char* g_module_name = NULL

static

Definition at line 79 of file comEngine_HRE_distribute.c.

Referenced by fill_HRE_module(), and HRE_distribute().

g_new_module_name

const char* g_new_module_name = NULL

static

Definition at line 78 of file comEngine_HRE_distribute.c.

Referenced by HRE_distribute(), and make_HRE_empty_module().

gCurStats

list gCurStats = NIL

static

Definition at line 73 of file comEngine_HRE_distribute.c.

Referenced by generate_code(), HRE_distribute(), HRE_distribute_seq(), HRE_distribute_stat(), and loop_enter().

gIfCount

int gIfCount = 0

static

Definition at line 84 of file comEngine_HRE_distribute.c.

Referenced by HRE_distribute(), HRE_distribute_call(), HRE_distribute_seq(), HRE_distribute_stat(), and HRE_distribute_test().

gIsIndex

hash_table gIsIndex

static

Definition at line 71 of file comEngine_HRE_distribute.c.

Referenced by find_or_create_newInd(), and HRE_distribute().

glCurLoop

list glCurLoop = NIL

static

Definition at line 88 of file comEngine_HRE_distribute.c.

Referenced by find_or_create_newInd(), generate_code(), get_indExp_from_ref(), HRE_distribute(), and HRE_distribute_loop().

glCurRep

list glCurRep = NIL

static

Definition at line 74 of file comEngine_HRE_distribute.c.

Referenced by generate_code(), HRE_distribute(), HRE_distribute_call(), and HRE_distribute_test().

glReadStats

list glReadStats = NIL

static

Definition at line 94 of file comEngine_HRE_distribute.c.

Referenced by add_index_statements(), generate_code(), generate_fifo_stat2(), and HRE_distribute().

glWriteStats

list glWriteStats = NIL

static

Definition at line 95 of file comEngine_HRE_distribute.c.

Referenced by add_index_statements(), generate_code(), generate_fifo_stat2(), and HRE_distribute().

gNewInd

entity gNewInd = entity_undefined

static

Definition at line 90 of file comEngine_HRE_distribute.c.

Referenced by add_index_statements(), find_or_create_newInd(), generate_code(), and HRE_distribute().

gOldIndToNewInd

hash_table gOldIndToNewInd

static

Definition at line 67 of file comEngine_HRE_distribute.c.

Referenced by add_index_statements(), find_or_create_newInd(), generate_code(), and HRE_distribute().