#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 "phrase.h"

Include dependency graph for comEngine_generate_code.c:

Functions
entity	comEngine_make_new_scalar_variable (const char *prefix, basic bas)

static void	fill_gLoopToOpt (list lRef)

static void	fill_gLoopToToggleEnt (statement stat, list lRef)

statement	make_toggle_init_statement (entity toggleEnt)

static void	update_toggle_init_stats_list (statement stat)

statement	make_toggle_inc_statement (entity toggleEnt, int val)

static void	add_toggle_inc_statements (statement stat, list lInStats)

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

static statement	usual_loop_tiling (statement stat, statement newBody, list lSupportedRef, list lUnSupportedRef, hash_table htOffset, expression bufferSizeExp, entity newOuterInd, entity newInnerInd)

static statement	generate_code_loop (statement stat)

static void	process_ref_lists (statement stat, list *lInRef)

static void	process_opt_replace (statement *newStat)

static list	replace_glCurRep_in_seq (list lStats, list lPrevSeq, list lSeq)

static statement	generate_code_seq (statement stat)

static statement	add_exec_mmcd (statement stat)

static statement	generate_code_call (statement stat, bool bCalledFromSeq)

static statement	process_code_seq (statement newStat, statement stat)

statement	generate_code_function (statement stat, bool bCalledFromSeq)

statement	comEngine_generate_code (statement stat)

Variables
hash_table	gLoopToOuterInd
	comEngine_generate_code.c More...

bool	gGenHRE = false

static bool	COM_OPT

static bool	gExecPut

static list	glCurRep = NIL

static hash_table	gHtCurNewInd

static list	glCurLoop = NIL

static list	glOutEffStats = NIL

list	glToggleInitStats

Function Documentation

◆ add_exec_mmcd()

static statement add_exec_mmcd ( statement stat )

static

Definition at line 938 of file comEngine_generate_code.c.

 {
   statement mmcdStat = make_exec_mmcd();
  
   statement stepStat = make_step_inc_statement(1);
  
   mmcdStat = make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL),
                                             CONS(STATEMENT, mmcdStat, NIL)));
  
   if(glCurLoop != NIL)
     {
       statement loopStat = STATEMENT(CAR(glCurLoop));
  
       list lUnSupportedRef = hash_get(gLoopToUnSupRef, loopStat);
  
       pips_assert("lUnSupportedRef != HASH_UNDEFINED_VALUE",
                   lUnSupportedRef != HASH_UNDEFINED_VALUE);
  
       if(lUnSupportedRef == NIL)
         {
           loop curLoop = statement_loop(loopStat);
  
           entity newInd = hash_get(gHtCurNewInd, loopStat);
  
           list neArg = gen_make_list(expression_domain,
                                      entity_to_expression(newInd),
                                      copy_expression(range_lower(loop_range(curLoop))),
                                      NULL);
  
           expression neExp = 
             call_to_expression(make_call(entity_intrinsic(C_EQUAL_OPERATOR_NAME),
                                          neArg));
  
           test t = make_test(neExp, mmcdStat, make_empty_statement());
  
           mmcdStat = 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());
         }
     }
  
   if(stat == statement_undefined)
     {
       return mmcdStat;
     }
   else
     {
       return make_block_statement(gen_nconc(CONS(STATEMENT, stat, NIL),
                                             CONS(STATEMENT, mmcdStat, NIL)));
     }
 }

References C_EQUAL_OPERATOR_NAME, call_to_expression(), CAR, CONS, copy_expression(), empty_comments, empty_extensions(), entity_empty_label(), entity_intrinsic(), entity_to_expression(), expression_domain, gen_make_list(), gen_nconc(), gHtCurNewInd, glCurLoop, gLoopToUnSupRef, hash_get(), HASH_UNDEFINED_VALUE, is_instruction_test, loop_range, make_block_statement(), make_call(), make_empty_statement, make_exec_mmcd(), make_instruction(), make_statement(), make_step_inc_statement(), make_synchronization_none(), make_test(), NIL, pips_assert, range_lower, STATEMENT, statement_loop(), STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, and statement_undefined.

Referenced by generate_code_call().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_toggle_inc_statements()

static void add_toggle_inc_statements	(	statement	stat,
		list	lInStats
	)

static

Definition at line 241 of file comEngine_generate_code.c.

 {
   list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
  
   pips_assert("lToggleEnt != HASH_UNDEFINED_VALUE",
                lToggleEnt!= HASH_UNDEFINED_VALUE);
  
   // The loop we consider is the first statement of the list lInStats
   statement newLoopStat = STATEMENT(CAR(lInStats));
  
   pips_assert("newLoopStat is a loop statement",
               statement_loop_p(newLoopStat));
  
   statement body = loop_body(statement_loop(newLoopStat));
  
   list lStats = CONS(STATEMENT, body, NIL);
  
   MAP(STATEMENT, loopStat,
   {
     if(loopStat == STATEMENT(CAR(glCurLoop)))
       {
         continue;
       }
  
     entity inInd = hash_get(gHtCurNewInd, loopStat);
  
     statement indStat = make_init_newInd_stat(loopStat, inInd);
  
     if(indStat != statement_undefined)
       {
         lStats = gen_nconc(CONS(STATEMENT, indStat, NIL), lStats);
       }
   }, glCurLoop);
  
   // For each toggle variable, create a statement to increment it
   MAP(ENTITY, toggleEnt,
   {
     statement mmcdStat = make_toggle_mmcd(toggleEnt);
  
     lStats = gen_nconc(CONS(STATEMENT, mmcdStat, NIL), lStats);
  
     intptr_t inc = (intptr_t)hash_get(gToggleToInc, toggleEnt);
  
     statement toggleStat =
       make_toggle_inc_statement(toggleEnt, inc);
  
     lStats = gen_nconc(lStats, CONS(STATEMENT, toggleStat, NIL));
   }, lToggleEnt);
  
   loop_body(statement_loop(newLoopStat)) = make_block_statement(lStats);
 }

References CAR, CONS, ENTITY, gen_nconc(), gHtCurNewInd, glCurLoop, gLoopToToggleEnt, gToggleToInc, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, loop_body, make_block_statement(), make_init_newInd_stat(), make_toggle_inc_statement(), make_toggle_mmcd(), MAP, NIL, pips_assert, STATEMENT, statement_loop(), statement_loop_p(), and statement_undefined.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comEngine_generate_code()

statement comEngine_generate_code ( statement stat )

Parameters

stat tat

Definition at line 1187 of file comEngine_generate_code.c.

 {
   statement newStat = statement_undefined;
  
   // Initialize some global variables
   COM_OPT = true;
   gExecPut = false;
   gLoopToOuterInd = hash_table_make(hash_pointer, 0);
   gHtCurNewInd = hash_table_make(hash_pointer, 0);
   glCurLoop = NIL;
   glCurRep = NIL;
   gLoopToOpt = hash_table_make(hash_pointer, 0);
   glOutEffStats = NIL;
   glToggleInitStats = NIL;
  
   // Do the job
   newStat = generate_code_function(stat, false);
  
   if(statement_block_p(stat))
     {
       newStat = process_code_seq(newStat, stat);
     }
  
   // Add the loop indices statements
   if(glOutEffStats != NIL)
     {
       newStat =
         make_block_statement(gen_nconc(CONS(STATEMENT, newStat, NIL),
                                        glOutEffStats));
     }
  
   // Add the toggle initialization statements
   if(glToggleInitStats != NIL)
     {
       newStat =
         make_block_statement(gen_nconc(glToggleInitStats,
                                        CONS(STATEMENT, newStat, NIL)));
     }
  
   // Free some global variables
   hash_table_free(gHtCurNewInd);
   hash_table_free(gLoopToOpt);
   hash_table_free(gLoopToOuterInd);
  
   return newStat;
 }

References COM_OPT, CONS, gen_nconc(), generate_code_function(), gExecPut, gHtCurNewInd, glCurLoop, glCurRep, gLoopToOpt, gLoopToOuterInd, glOutEffStats, glToggleInitStats, hash_pointer, hash_table_free(), hash_table_make(), make_block_statement(), NIL, process_code_seq(), STATEMENT, statement_block_p, and statement_undefined.

Referenced by comEngine_generate_HRECode(), and comEngine_generate_procCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comEngine_make_new_scalar_variable()

entity comEngine_make_new_scalar_variable	(	const char *	prefix,
		basic	bas
	)

Parameters

prefix	refix
bas	as

Definition at line 94 of file comEngine_generate_code.c.

 {
   entity retEnt = entity_undefined;
   make_new_scalar_variable_with_prefix(prefix,
                                              get_current_module_entity(),
                                              bas);
   AddEntityToCurrentModule(retEnt);
  
   return retEnt;
 }

References AddEntityToCurrentModule(), entity_undefined, get_current_module_entity(), make_new_scalar_variable_with_prefix(), and prefix.

Referenced by comEngine_generate_procCode(), fill_gLoopToToggleEnt(), generate_code_loop(), regenerate_toggles(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_gLoopToOpt()

static void fill_gLoopToOpt ( list lRef )

static

Definition at line 110 of file comEngine_generate_code.c.

 {
   if(lRef != NIL)
     {
       MAP(STATEMENT, loopStat,
       {
         hash_put(gLoopToOpt, loopStat, (void *)false);
       }, glCurLoop);
     }
 }

References glCurLoop, gLoopToOpt, hash_put(), MAP, NIL, and STATEMENT.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_gLoopToToggleEnt()

static void fill_gLoopToToggleEnt	(	statement	stat,
		list	lRef
	)

static

Definition at line 125 of file comEngine_generate_code.c.

 {
   list lDone = NIL;
  
   // Go through the reference list attached to this loop
   FOREACH(REFERENCE, curRef, lRef)
   {
     // Get the fifo number for the current reference
     intptr_t fifoNum = (intptr_t)hash_get(gRefToFifo, curRef);
  
     pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
                 fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
  
     // Get the fifo offset for the cureent reference
     intptr_t inc = (intptr_t)hash_get(gRefToFifoOff, (void *)fifoNum);
  
     pips_assert("inc != HASH_UNDEFINED_VALUE",
                 inc != (intptr_t)HASH_UNDEFINED_VALUE);
  
     bool bDone = false;
  
     // If a toggle variable has already been created for this loop,
     // then continue
     MAP(INT, incDone,
     {
       if(inc == incDone)
         {
           bDone = true;
           break;
         }
     }, lDone);
  
     if(bDone)
       continue;
  
     lDone = CONS(INT, inc, lDone);
  
     // Create a new toggle variable
     entity toggleEnt = 
       comEngine_make_new_scalar_variable(strdup("toggle"),
                                          make_basic(is_basic_int, (void *)4));
  
     list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
  
     if(lToggleEnt == HASH_UNDEFINED_VALUE)
       {
         lToggleEnt = NIL;
       }
  
     // Store the new variable in the list of toggle variables
     lToggleEnt = CONS(ENTITY, toggleEnt, lToggleEnt);
  
     hash_put(gLoopToToggleEnt, stat, lToggleEnt);
  
     // Associate the value corresponding to the fifo offset to the toggle
     // variable
     hash_put(gToggleToInc, toggleEnt, (void *)inc);
  
   }
 }

References comEngine_make_new_scalar_variable(), CONS, ENTITY, FOREACH, gLoopToToggleEnt, gRefToFifo, gRefToFifoOff, gToggleToInc, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, INT, intptr_t, is_basic_int, make_basic(), MAP, NIL, pips_assert, REFERENCE, and strdup().

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_code_call()

static statement generate_code_call	(	statement	stat,
		bool	bCalledFromSeq
	)

static

Definition at line 998 of file comEngine_generate_code.c.

 {
   //printf("generate_code_call\n");
   //print_statement(stat);printf("\n");
   statement newStat = statement_undefined;
  
   if(gGenHRE)
     {
       newStat = get_call_stat_HRE(stat);
     }
   else
     {
       newStat = get_call_stat_proc(stat);
     }
  
   if(COM_OPT && gGenHRE)
     {
       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(!bCalledFromSeq)
         {
           process_opt_replace(&newStat);
         }
     }
  
   if(!get_bool_property("COMENGINE_CONTROL_IN_HRE")
      && !gGenHRE && !gExecPut)
     {
       newStat = add_exec_mmcd(newStat);
  
       gExecPut = true;
     }
  
   if(get_bool_property("COMENGINE_CONTROL_IN_HRE") &&
      !gExecPut)
     {
       statement stepStat;
  
       if(gGenHRE)
         {
           stepStat = make_wait_step_statement();
         }
       else
         {
           stepStat = make_step_inc_statement(1);
         }
  
       if(newStat == statement_undefined)
         {
           newStat = stepStat;
         }
       else
         {
           newStat =
             make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL),
                                            CONS(STATEMENT, newStat, NIL)));
         }
  
       gExecPut = true;
     }
  
   list lRef = hash_get(gStatToRef, stat);
  
   if(lRef == HASH_UNDEFINED_VALUE)
     {
       return newStat;
     }
  
   if(gGenHRE)
     {
       if(!COM_OPT)
         {
           process_replacement_HRE(lRef, expression_undefined, &newStat);
         }
  
       newStat = generate_stat_from_ref_list_HRE(lRef, newStat);
     }
   else
     {
       newStat = generate_stat_from_ref_list_proc(lRef, NIL, newStat);
  
       fill_gLoopToOpt(lRef);
     }
       printf("generate_code_call 2\n");
   return newStat;
 }

References add_exec_mmcd(), call_arguments, COM_OPT, comEngine_expression_to_reference_list(), CONS, exp, EXPRESSION, expression_undefined, fill_gLoopToOpt(), gen_concatenate(), gen_free_list(), gen_nconc(), generate_stat_from_ref_list_HRE(), generate_stat_from_ref_list_proc(), get_bool_property(), get_call_stat_HRE(), get_call_stat_proc(), gExecPut, gGenHRE, glCurRep, gStatToRef, hash_get(), HASH_UNDEFINED_VALUE, instruction_call, make_block_statement(), make_step_inc_statement(), make_wait_step_statement(), MAP, NIL, printf(), process_opt_replace(), process_replacement_HRE(), STATEMENT, statement_instruction, and statement_undefined.

Referenced by generate_code_function().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_code_function()

statement generate_code_function	(	statement	stat,
		bool	bCalledFromSeq
	)

Parameters

stat	tat
bCalledFromSeq	CalledFromSeq

Definition at line 1137 of file comEngine_generate_code.c.

 {
   statement newStat = statement_undefined;
  
   instruction instr = statement_instruction(stat);
  
   switch(instruction_tag(instr))
     {
     case is_instruction_sequence:
       {
         newStat = generate_code_seq(stat);
  
         break;
       }
     case is_instruction_loop:
       {
         newStat = generate_code_loop(stat);
         break;
       }
     case is_instruction_call:
       {
         newStat = generate_code_call(stat, bCalledFromSeq);
         break;
       }
     case is_instruction_test:
       {
         if(gGenHRE)
           {
             newStat = generate_code_test_HRE(stat);
           }
         else
           {
             newStat = generate_code_test_proc(stat);
           }
         break;
       }
     default:
       {
         pips_assert("FALSE", false);
         break;
       }
     }
  
   return newStat;
 }

References generate_code_call(), generate_code_loop(), generate_code_seq(), generate_code_test_HRE(), generate_code_test_proc(), gGenHRE, instruction_tag, is_instruction_call, is_instruction_loop, is_instruction_sequence, is_instruction_test, pips_assert, statement_instruction, and statement_undefined.

Referenced by comEngine_generate_code(), generate_code_loop(), generate_code_seq(), generate_code_test_HRE(), and generate_code_test_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_code_loop()

static statement generate_code_loop ( statement stat )

static

Definition at line 501 of file comEngine_generate_code.c.

 {
   printf("generate_code_loop\n");
   print_statement(stat);
  
   statement newBody = statement_undefined;
  
   list lStats = NIL;
  
   hash_table htOffset = hash_get(gStatToHtOffset, stat);
  
   if(!gGenHRE)
     {
       pips_assert("htOffset != HASH_UNDEFINED_VALUE",
                   htOffset != HASH_UNDEFINED_VALUE);
     }
  
   loop curLoop = statement_loop(stat);
  
   list lRef = hash_get(gLoopToRef, stat);
  
   if(lRef == HASH_UNDEFINED_VALUE)
     {
       lRef = NIL;
     }
  
   list lSupportedRef = NIL;
   list lUnSupportedRef = NIL;
  
   // Store the list of supported and unsupported references for loop
   // statement stat.
   get_supportedRef_HRE(stat,
                        &lSupportedRef, &lUnSupportedRef);
  
   // Create a new index
   entity newOuterInd =
     comEngine_make_new_scalar_variable(entity_local_name(loop_index(curLoop)),
                                        copy_basic(entity_basic(loop_index(curLoop))));
  
   // Memorize the index created in the hash_table gLoopToOuterInd
   hash_put(gLoopToOuterInd, stat, newOuterInd);
  
   // Create a new index
   entity newInnerInd = 
     comEngine_make_new_scalar_variable(entity_local_name(loop_index(curLoop)),
                                        copy_basic(entity_basic(loop_index(curLoop))));
  
   // If we are generating the MMCD code, then create the fifos for the
   // supported and unsupported references
   if(!gGenHRE)
     {
       create_realFifo_proc(stat, lSupportedRef);
       create_realFifo_proc(stat, lUnSupportedRef);
     }
  
   // Create the toggle references and store them in gLoopToToggleEnt
   fill_gLoopToToggleEnt(stat, lSupportedRef);
   fill_gLoopToToggleEnt(loop_body(statement_loop(stat)), lUnSupportedRef);
  
   // Add the loop to the current loops list
   glCurLoop = CONS(STATEMENT, stat, glCurLoop);
  
   // Memorize the current newInnerInd in gHtCurNewInd
   hash_put(gHtCurNewInd, stat, newInnerInd);
  
   hash_put(gLoopToOpt, stat, (void *)true);
  
   gExecPut = false;
  
   // Get the new statements for the loop body
   newBody = generate_code_function(loop_body(curLoop), false);
  
   gExecPut = false;
  
   printf("newBody real\n");
   if(newBody == statement_undefined)
     {
       printf("undefined\n");
     }
   else
     {
       print_statement(newBody);
     }
  
   // If there are some supported references, the let us perform a loop
   // tiling operation
   if(lSupportedRef != NIL)
     {
       expression bufferSizeExp = expression_undefined;
  
       bufferSizeExp = copy_expression(gBufferSizeEnt);
  
       statement newStat = usual_loop_tiling(stat, newBody,
                                             lSupportedRef, lUnSupportedRef,
                                             htOffset, bufferSizeExp,
                                             newOuterInd, newInnerInd);
  
       list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
  
       if(lToggleEnt != HASH_UNDEFINED_VALUE)
         {
           printf("put lToggleEnt\n");
           print_statement(newStat);
           hash_put(gLoopToToggleEnt, newStat, gen_copy_seq(lToggleEnt));
         }
  
       lStats = CONS(STATEMENT, newStat, NIL);
  
       if(!gGenHRE)
         {
           glOutEffStats = add_index_out_effect_proc(curLoop, glOutEffStats);
         }
     }
   // else if the new body is not undefined, then just create a loop without
   // loop tiling
   else if(newBody != statement_undefined)
     {
       // If there are some unsupported references, then let us add some
       // statements to the code to support them
       if(lUnSupportedRef != NIL)
         {
           // Let us do what needs to be done to handle the references list
           if(gGenHRE)
             {
               if(!COM_OPT)
                 {
                   process_replacement_HRE(lUnSupportedRef, expression_undefined, &newBody);
                 }
  
               newBody = generate_stat_from_ref_list_HRE(lUnSupportedRef, newBody);
             }
           else
             {
               list lToggleEnt = hash_get(gLoopToToggleEnt,
                                          loop_body(statement_loop(stat)));
  
               if(lToggleEnt == HASH_UNDEFINED_VALUE)
                 {
                   lToggleEnt = NIL;
                 }
  
               newBody = generate_stat_from_ref_list_proc(lUnSupportedRef,
                                                          lToggleEnt,
                                                          newBody);
  
               fill_gLoopToOpt(lUnSupportedRef);
             }
         }
  
       // The following lines create the loop
       loop outerLoop = make_loop(newInnerInd,
                                  copy_range(loop_range(curLoop)),
                                  newBody,
                                  loop_label(curLoop),
                                  make_execution(is_execution_sequential, UU),
                                  NIL);
  
       statement newStat = make_statement(entity_empty_label(),
                                          STATEMENT_NUMBER_UNDEFINED,
                                          STATEMENT_ORDERING_UNDEFINED,
                                          empty_comments,
                                          make_instruction_loop(outerLoop),NIL,NULL,
                                          empty_extensions (), make_synchronization_none());
  
       lStats = CONS(STATEMENT, newStat, NIL);
  
       comEngine_replace_reference_in_stat(newBody,
                                           make_reference(loop_index(curLoop), NIL),
                                           entity_to_expression(newInnerInd));
  
       if(!gGenHRE)
         {
           glOutEffStats = add_index_out_effect_proc(curLoop, glOutEffStats);
         }
     }
   else
     {
       return make_block_statement(NIL);
     }
  
   if(!gGenHRE)
     {
       add_toggle_inc_statements(stat, lStats);
  
       update_toggle_init_stats_list(stat);
     }
  
   //pips_assert("newStat != statement_undefined",
   //newStat != statement_undefined);
  
   // If some references attached to the loop statement but are not
   // some supported or unsupported references, then let us handle them
   list lOutRef = hash_get(gStatToRef, stat);
  
   if(lOutRef != HASH_UNDEFINED_VALUE)
     {
       // Let us do what needs to be done to handle the references list
       if(gGenHRE)
         {
           if(!COM_OPT)
             {
               lStats = process_replacement_HRE_OutRef(lOutRef, lStats);
             }
  
           lStats = generate_stat_from_ref_list_HRE_list(lOutRef, lStats);
         }
       else
         {
           lStats = generate_stat_from_ref_list_proc_list(lOutRef, lStats);
  
           fill_gLoopToOpt(lOutRef);
         }
     }
  
   // Add some bubbles in the pipeline if needed
   if(gGenHRE)
     {
       lStats = process_gLoopToSync_HRE(stat, lStats);
  
       //fill_gLoopToOpt(!NIL);
     }
   else
     {
       lStats = process_gLoopToSync_proc(stat, lStats);
  
       //fill_gLoopToOpt(!NIL);
     }
   
   if(!gGenHRE)
     {
       hash_table_free(htOffset);
     }
  
   // Remove the loop statement to the current loops list
   gen_remove(&glCurLoop, stat);
  
   statement newStat = make_block_statement(lStats);
  
   printf("newStat real\n");
   if(newStat == statement_undefined)
     {
       printf("newStat == statement_undefined\n");
     }
   else
     {
       print_statement(newStat);
     }
  
   hash_put(gIsNewLoop, newStat, (void *)true);
  
   return newStat;
 }

References add_index_out_effect_proc(), add_toggle_inc_statements(), COM_OPT, comEngine_make_new_scalar_variable(), comEngine_replace_reference_in_stat(), CONS, copy_basic(), copy_expression(), copy_range(), create_realFifo_proc(), empty_comments, empty_extensions(), entity_basic(), entity_empty_label(), entity_local_name(), entity_to_expression(), expression_undefined, fill_gLoopToOpt(), fill_gLoopToToggleEnt(), gBufferSizeEnt, gen_copy_seq(), gen_remove(), generate_code_function(), generate_stat_from_ref_list_HRE(), generate_stat_from_ref_list_HRE_list(), generate_stat_from_ref_list_proc(), generate_stat_from_ref_list_proc_list(), get_supportedRef_HRE(), gExecPut, gGenHRE, gHtCurNewInd, gIsNewLoop, glCurLoop, gLoopToOpt, gLoopToOuterInd, gLoopToRef, gLoopToToggleEnt, glOutEffStats, gStatToHtOffset, gStatToRef, hash_get(), hash_put(), hash_table_free(), HASH_UNDEFINED_VALUE, is_execution_sequential, loop_body, loop_index, loop_label, loop_range, make_block_statement(), make_execution(), make_instruction_loop(), make_loop(), make_reference(), make_statement(), make_synchronization_none(), NIL, pips_assert, print_statement(), printf(), process_gLoopToSync_HRE(), process_gLoopToSync_proc(), process_replacement_HRE(), process_replacement_HRE_OutRef(), STATEMENT, statement_loop(), STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, statement_undefined, update_toggle_init_stats_list(), usual_loop_tiling(), and UU.

Referenced by generate_code_function().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_code_seq()

static statement generate_code_seq ( statement stat )

static

Definition at line 865 of file comEngine_generate_code.c.

 {
   statement newStat = statement_undefined;
  
   instruction instr = statement_instruction(stat);
  
   list lSeq = NIL;
   list lTempSeq = NIL;
   list lPrevSeq = NIL;
  
   //printf("generate_code_seq\n");
  
   // Go through each statement of the sequence
   MAP(STATEMENT, curStat,
   {
     if((COM_OPT && gGenHRE)&& !statement_call_p(curStat) &&
        !statement_test_p(curStat))
       {
         lSeq = replace_glCurRep_in_seq(lTempSeq, lPrevSeq, lSeq);
  
         lTempSeq = NIL;
       }
  
     // Let us get the new statement for the current sequence statement
     statement seqNewStat = generate_code_function(curStat, true);
  
     if(seqNewStat != statement_undefined)
       {
         list newStatCons = CONS(STATEMENT, seqNewStat, NIL);
  
         lSeq = gen_nconc(lSeq, newStatCons);
  
         if((COM_OPT && gGenHRE)&&!statement_call_p(curStat) &&
            !statement_test_p(curStat))
           {
             lPrevSeq = newStatCons;
           }
  
         if((COM_OPT && gGenHRE)&&(lTempSeq == NIL) &&
            (statement_call_p(curStat) ||
             statement_test_p(curStat)))
           {
             lTempSeq = newStatCons;
           }
       }
  
   }, sequence_statements(instruction_sequence(instr)));
  
   if(COM_OPT && gGenHRE)
     {
       lSeq = replace_glCurRep_in_seq(lTempSeq, lPrevSeq, lSeq);
     }
  
   if(lSeq == NIL)
     {
       newStat = statement_undefined;
     }
   else if(gen_length(lSeq) == 1)
     {
       newStat = STATEMENT(CAR(lSeq));
     }
   else
     {
       newStat = make_block_statement(lSeq);
     }
  
   return newStat;
 }

References CAR, COM_OPT, CONS, gen_length(), gen_nconc(), generate_code_function(), gGenHRE, instruction_sequence, make_block_statement(), MAP, NIL, replace_glCurRep_in_seq(), sequence_statements, STATEMENT, statement_call_p(), statement_instruction, statement_test_p(), and statement_undefined.

Referenced by generate_code_function().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_loopStat1()

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

static

Definition at line 297 of file comEngine_generate_code.c.

 {
   loop curLoop = statement_loop(stat);
  
   if(innerStat != statement_undefined)
     {
       expression indExp = entity_to_expression(newInnerInd);
  
       // If we are generating the HRE code, then replace the references by
       // the private HRE references
       if(gGenHRE)
         {
           if(!COM_OPT)
             {
               process_replacement_HRE(lSupportedRef, indExp, &loop_body(statement_loop(innerStat)));
             }
         }
  
       free_expression(indExp);
     }
  
   // Add some statements to the innerStat
   list lStats = NIL;
   if(gGenHRE)
     {
       lStats = make_loop_lStats_HRE(stat, transferSize,
                                     innerStat, newOuterInd,
                                     lSupportedRef, htOffset,
                                     bufferSizeExp);
     }
   else
     {
       lStats = make_loop_lStats_proc(stat, transferSize,
                                      innerStat, newOuterInd,
                                      lSupportedRef, htOffset,
                                      bufferSizeExp);
     }
  
   innerStat = make_block_statement(lStats);
  
   // The following lines create the outer loop of the loop tiling
   // operation
   range outerRange1 = make_range(copy_expression(range_lower(loop_range(curLoop))),
                                  copy_expression(range_upper(loop_range(curLoop))),
                                  copy_expression(bufferSizeExp));
  
   loop outerLoop1 = make_loop(newOuterInd,
                               outerRange1,
                               innerStat,
                               loop_label(curLoop),
                               make_execution(is_execution_sequential, UU),
                               NIL);
  
   return make_statement(entity_empty_label(),
                         STATEMENT_NUMBER_UNDEFINED,
                         STATEMENT_ORDERING_UNDEFINED,
                         empty_comments,
                         make_instruction_loop(outerLoop1),NIL,NULL,
                         empty_extensions (), make_synchronization_none());
 }

References COM_OPT, copy_expression(), empty_comments, empty_extensions(), entity_empty_label(), entity_to_expression(), free_expression(), gGenHRE, is_execution_sequential, loop_body, loop_label, loop_range, make_block_statement(), make_execution(), make_instruction_loop(), make_loop(), make_loop_lStats_HRE(), make_loop_lStats_proc(), make_range(), make_statement(), make_synchronization_none(), NIL, process_replacement_HRE(), range_lower, range_upper, statement_loop(), STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, statement_undefined, and UU.

Referenced by usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_toggle_inc_statement()

statement make_toggle_inc_statement	(	entity	toggleEnt,
		int	val
	)

Parameters

toggleEnt	oggleEnt
val	al

Definition at line 222 of file comEngine_generate_code.c.

 {
   list modArg = gen_make_list(expression_domain,
                               entity_to_expression(toggleEnt),
                               int_to_expression(val),
                               NULL);
  
   expression modExp =
     call_to_expression(make_call(entity_intrinsic(C_MODULO_OPERATOR_NAME),
                                  modArg));
  
   return make_assign_statement(entity_to_expression(toggleEnt),
                                modExp);
 }

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

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

statement make_toggle_init_statement ( entity toggleEnt )

Parameters

toggleEnt oggleEnt

Definition at line 189 of file comEngine_generate_code.c.

 {
   return make_assign_statement(entity_to_expression(toggleEnt),
                                int_to_expression(0));
 }

References entity_to_expression(), int_to_expression(), and make_assign_statement().

Referenced by regenerate_toggles(), and update_toggle_init_stats_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_code_seq()

static statement process_code_seq	(	statement	newStat,
		statement	stat
	)

static

Definition at line 1105 of file comEngine_generate_code.c.

 {
   list lRef = hash_get(gStatToRef, stat);
  
   if(lRef == HASH_UNDEFINED_VALUE)
     {
       return newStat;
     }
  
   if(gGenHRE)
     {
       if(!COM_OPT)
         {
           process_replacement_HRE(lRef, expression_undefined, &newStat);
         }
  
       newStat = generate_stat_from_ref_list_HRE(lRef, newStat);
     }
   else
     {
       newStat = generate_stat_from_ref_list_proc(lRef, NIL, newStat);
  
       fill_gLoopToOpt(lRef);
     }
  
   return newStat;
 }

References COM_OPT, expression_undefined, fill_gLoopToOpt(), generate_stat_from_ref_list_HRE(), generate_stat_from_ref_list_proc(), gGenHRE, gStatToRef, hash_get(), HASH_UNDEFINED_VALUE, NIL, and process_replacement_HRE().

Referenced by comEngine_generate_code().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_opt_replace()

static void process_opt_replace ( statement * newStat )

static

Definition at line 799 of file comEngine_generate_code.c.

 {
   MAP(STATEMENT, loopStat,
   {
     list lIn = NIL;
  
     process_ref_lists(loopStat, &lIn);
  
     entity curNewInd = hash_get(gHtCurNewInd, loopStat);
  
     pips_assert("curNewInd != HASH_UNDEFINED_VALUE",
                 curNewInd != HASH_UNDEFINED_VALUE);
  
     expression indExp = entity_to_expression(curNewInd);
  
     process_replacement_HRE(lIn, indExp, newStat);
  
     free_expression(indExp);
  
     gen_free_list(lIn);
  
   }, glCurLoop);
  
   process_replacement_HRE(glCurRep, expression_undefined, newStat);
  
   fill_gLoopToOpt(glCurRep);
  
   gen_free_list(glCurRep);
   glCurRep = NIL;
 }

References entity_to_expression(), expression_undefined, fill_gLoopToOpt(), free_expression(), gen_free_list(), gHtCurNewInd, glCurLoop, glCurRep, hash_get(), HASH_UNDEFINED_VALUE, MAP, NIL, pips_assert, process_ref_lists(), process_replacement_HRE(), and STATEMENT.

Referenced by generate_code_call(), and replace_glCurRep_in_seq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_ref_lists()

static void process_ref_lists	(	statement	stat,
		list *	lInRef
	)

static

Definition at line 758 of file comEngine_generate_code.c.

 {
   list lRef = NIL;
  
   lRef = hash_get(gLoopToSupRef, stat);
  
   if(lRef == HASH_UNDEFINED_VALUE)
     {
       lRef = NIL;
     }
  
   MAP(REFERENCE, curRef,
   {
     bool bInRef = false;
  
     MAP(REFERENCE, supRef,
     {
       if(reference_equal_p(curRef, supRef))
         {
           bInRef = true;
           break;
         }
     }, lRef);
  
     if(bInRef)
       {
         *lInRef = CONS(REFERENCE, curRef, *lInRef);
       }
  
   }, glCurRep);
  
   MAP(REFERENCE, curRef,
   {
     gen_remove(&glCurRep, curRef);
   }, *lInRef);
 }

References CONS, gen_remove(), glCurRep, gLoopToSupRef, hash_get(), HASH_UNDEFINED_VALUE, MAP, NIL, REFERENCE, and reference_equal_p().

Referenced by process_opt_replace().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ replace_glCurRep_in_seq()

static list replace_glCurRep_in_seq	(	list	lStats,
		list	lPrevSeq,
		list	lSeq
	)

static

Definition at line 834 of file comEngine_generate_code.c.

 {
   list newLStats = NIL;
  
   if(lStats == NIL)
     {
       return lSeq;
     }
  
   statement newStat = make_block_statement(lStats);
  
   process_opt_replace(&newStat);
  
   newLStats = CONS(STATEMENT, newStat, NIL);
  
   if(lPrevSeq != NIL)
     {
       CDR(lPrevSeq) = newLStats;
     }
   else
     {
       lSeq = newLStats;
     }
  
   return lSeq;
 }

References CDR, CONS, make_block_statement(), NIL, process_opt_replace(), and STATEMENT.

Referenced by generate_code_seq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_toggle_init_stats_list()

static void update_toggle_init_stats_list ( statement stat )

static

Definition at line 198 of file comEngine_generate_code.c.

 {
   list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
  
   pips_assert("lToggleEnt != HASH_UNDEFINED_VALUE",
               lToggleEnt != HASH_UNDEFINED_VALUE);
  
   list lStats = NIL;
  
   MAP(ENTITY, toggleEnt,
   {
     // Create an initialization statement for the curren toggle variable
     statement toggleStat = make_toggle_init_statement(toggleEnt);
  
     lStats = gen_nconc(lStats, CONS(STATEMENT, toggleStat, NIL));
   }, lToggleEnt);
  
   glToggleInitStats = gen_nconc(glToggleInitStats, lStats);
 }

References CONS, ENTITY, gen_nconc(), gLoopToToggleEnt, glToggleInitStats, hash_get(), HASH_UNDEFINED_VALUE, make_toggle_init_statement(), MAP, NIL, pips_assert, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ usual_loop_tiling()

static statement usual_loop_tiling	(	statement	stat,
		statement	newBody,
		list	lSupportedRef,
		list	lUnSupportedRef,
		hash_table	htOffset,
		expression	bufferSizeExp,
		entity	newOuterInd,
		entity	newInnerInd
	)

static

Definition at line 393 of file comEngine_generate_code.c.

 {
   loop curLoop = statement_loop(stat);
  
   statement innerStat1 = statement_undefined;
  
   statement loopStat1 = statement_undefined;
  
   entity transferSize =
     comEngine_make_new_scalar_variable(strdup("transSize"),
                                        make_basic(is_basic_int, (void*)4));
  
   // If the new body is not undefined, then create the inner loop.
   if((newBody != statement_undefined) ||
      (lUnSupportedRef != NIL))
     {
       // If there are some unsupported references, then let us add some
       // statements to the code to support them
       if(lUnSupportedRef != NIL)
         {
           // Let us do what needs to be done to handle the references list
           if(gGenHRE)
             {
               if(!COM_OPT)
                 {
                   process_replacement_HRE(lUnSupportedRef, expression_undefined, &newBody);
                 }
  
               newBody = generate_stat_from_ref_list_HRE(lUnSupportedRef, newBody);
             }
           else
             {
               list lToggleEnt = hash_get(gLoopToToggleEnt,
                                          loop_body(statement_loop(stat)));
  
               if(lToggleEnt == HASH_UNDEFINED_VALUE)
                 {
                   lToggleEnt = NIL;
                 }
  
               newBody = generate_stat_from_ref_list_proc(lUnSupportedRef,
                                                          lToggleEnt,
                                                          newBody);
  
               fill_gLoopToOpt(lUnSupportedRef);
             }
         }
       else if(newBody == statement_undefined)
         {
           newBody = make_block_statement(NIL);
         }
  
       //newBody = make_init_prev_ind(newBody);
  
       // The following lines create the inner loop of the loop tiling
       // operation
       range innerRange = make_range(int_to_expression(0),
                                     entity_to_expression(transferSize),
                                     int_to_expression(1));
  
       loop innerLoop = make_loop(newInnerInd,
                                  innerRange,
                                  newBody,
                                  loop_label(curLoop),
                                  make_execution(is_execution_sequential, UU),
                                  NIL);
  
       innerStat1 = make_statement(entity_empty_label(),
                                   STATEMENT_NUMBER_UNDEFINED,
                                   STATEMENT_ORDERING_UNDEFINED,
                                   empty_comments,
                                   make_instruction_loop(innerLoop),NIL,NULL,
                                   empty_extensions (), make_synchronization_none());
  
       if(!gGenHRE)
         {
           process_innerStat1_proc(innerStat1, loop_index(curLoop),
                                   newOuterInd, newInnerInd);
         }
  
       //printf("innerStat1\n");
       //print_statement(innerStat1);
  
       // Let us try and see if we can optimize the transfers
       if(COM_OPT)
         {
           innerStat1 = comEngine_opt_loop_interchange(stat, innerStat1,
           newOuterInd);
         }
  
     }
  
   // This function finishes the loop tiling operation
   loopStat1 = make_loopStat1(stat, transferSize,
                              innerStat1, newOuterInd,
                              lSupportedRef, htOffset,
                              bufferSizeExp, newInnerInd);
  
   return loopStat1;
 }