comEngine_distribute.c

Go to the documentation of this file.

/*
 
  $Id: comEngine_distribute.c 23412 2017-08-09 15:07:09Z irigoin $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
#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 "effects-util.h"
#include "pipsdbm.h"
 
#include "text-util.h"
#include "properties.h"
#include "prettyprint.h"
 
#include "transformer.h"
 
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
#include "semantics.h"
#include "control.h"
#include "callgraph.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"
 
hash_table gLoopToRef;
hash_table gStatToRef;
hash_table gRefToEff;
hash_table gLoopToSync;
hash_table gLoopToSupRef;
hash_table gLoopToUnSupRef;
entity gHREMemory;
expression gBufferSizeEnt;
int gBufferSize;
hash_table gRefToFifo;
hash_table gRefToFifoOff;
hash_table gRefToHREFifo;
hash_table gStatToHtOffset;
hash_table gRefToBuffSize;
hash_table gIndToNum;
hash_table gRefToInd;
hash_table gLoopToToggleEnt;
hash_table gEntToHREFifo;
hash_table gRefToToggle;
hash_table gToggleToInc;
hash_table gIsNewLoop;
 
static entity  make_new_symbolic_entity(string inName)
{
  string name = strdup(concatenate(TOP_LEVEL_MODULE_NAME,
                                   MODULE_SEP_STRING, inName, NULL));
 
  entity newEnt = make_entity(name,
                              make_type(is_type_variable,
                                        make_variable(make_basic(is_basic_int, (void *)4), 
                                                      NIL,
                                                      NIL)),
                              make_storage(is_storage_rom, UU),
                              make_value(is_value_unknown, UU));
  
  return newEnt;
}
 
static void give_value_to_symbolic_entity(entity ent, intptr_t val)
{
  constant constVal = make_constant(is_constant_int, (void *)val);
 
  entity_initial(ent) = make_value(is_value_constant, constVal);
}
 
static int gCurVar = 0;
static int gCurBuff = 0;
static int gMaxVar = 0;
static int gMaxBuff = 0;
 
static void update_max()
{
  if(gCurBuff > gMaxBuff)
    {
      gMaxBuff = gCurBuff;
    }
 
  if(gCurVar > gMaxVar)
    {
      gMaxVar = gCurVar;
    }
}
 
static void update_HRE_mapping_from_list(list lRef, bool supRef, int inc)
{
  //printf("update_HRE_mapping_from_list\n");
  MAP(REFERENCE, curRef,
  {
    //printf("curRef\n");
    //print_reference(curRef);printf("\n");
 
    if(supRef)
      {
        gCurBuff += inc;
        hash_put(gRefToBuffSize, curRef, (void *)true);
      }
    else
      {
        gCurVar += inc;
      }
  }, lRef);
}
 
static void do_HRE_memory_mapping(statement stat);
 
static void do_HRE_memory_mapping_loop(statement stat)
{
  list lSupportedRef = NIL;
  list lUnSupportedRef = NIL;
 
  hash_table htOffset = hash_table_make(hash_pointer, 0);
 
  get_supportedRef_proc(stat, htOffset,
                        &lSupportedRef, &lUnSupportedRef);
 
  hash_put(gStatToHtOffset, stat, htOffset);
 
  update_HRE_mapping_from_list(lSupportedRef, true, 1);
  update_HRE_mapping_from_list(lUnSupportedRef, false, 1);
 
  update_max();
 
  do_HRE_memory_mapping(loop_body(statement_loop(stat)));
 
  update_HRE_mapping_from_list(lSupportedRef, true, -1);
  update_HRE_mapping_from_list(lUnSupportedRef, false, -1);
}
 
static void do_HRE_memory_mapping_stat(statement stat)
{
  list lRef = hash_get(gStatToRef, stat);
 
  if(lRef != HASH_UNDEFINED_VALUE)
    {
      update_HRE_mapping_from_list(lRef, false, 1);
 
      update_max();
 
      update_HRE_mapping_from_list(lRef, false, -1);
    }
}
 
static void do_HRE_memory_mapping(statement stat)
{
  //printf("do_HRE_memory_mapping\n");
 
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_sequence:
      {
        do_HRE_memory_mapping_stat(stat);
 
        MAP(STATEMENT, curStat,
        {
          do_HRE_memory_mapping(curStat);
 
        }, sequence_statements(instruction_sequence(instr)));
        break;
      }
    case is_instruction_loop:
      {
        do_HRE_memory_mapping_loop(stat);
        break;
      }
    case is_instruction_call:
    case is_instruction_test:
      {
        do_HRE_memory_mapping_stat(stat);
        break;
      }
    default:
      {
        pips_internal_error("impossible");
        break;
      }
    }
}
 
static bool compute_HRE_memory_mapping(statement stat, int hreMemSize)
{
  gCurVar = 0;
  gCurBuff = 0;
  gMaxVar = 0;
  gMaxBuff = 0;
 
  entity newEnt = make_new_symbolic_entity("COMENGINE_BUFFER_SIZE");
 
  gBufferSizeEnt = entity_to_expression(newEnt);
 
  do_HRE_memory_mapping(stat);
 
  //printf("gMaxVar %d\n", gMaxVar);
  //printf("gMaxBuff %d\n", gMaxBuff);
 
  if(gMaxBuff != 0)
    {
      gBufferSize = (hreMemSize - gMaxVar) / gMaxBuff;
    }
  else
    {
      gBufferSize = (hreMemSize - gMaxVar);
    }
 
  give_value_to_symbolic_entity(newEnt, gBufferSize);
 
  //printf("gBufferSize %d\n", gBufferSize);
 
  return true;
}
 
static void move_declarations(entity new_fun, statement stat)
{
  list lEnt = NIL;
 
  MAP(ENTITY, curEnt,
  {
    if(!type_varargs_p(entity_type(curEnt)) &&
       !type_statement_p(entity_type(curEnt)) &&
       !type_area_p(entity_type(curEnt)))
      {
        lEnt = gen_nconc(lEnt, CONS(ENTITY, curEnt, NIL));
      }
 
  }, code_declarations(value_code(entity_initial(new_fun))));
 
  statement_declarations(stat) = lEnt;
 
  gen_free_list(code_declarations(value_code(entity_initial(new_fun))));
 
  code_declarations(value_code(entity_initial(new_fun))) = NIL;
}
 
#define ALL_DECLS  "PRETTYPRINT_ALL_DECLARATIONS"
#define STAT_ORDER "PRETTYPRINT_STATEMENT_NUMBER"
 
void create_HRE_module(const char* new_module_name,
                       const char* module_name,
                       statement stat, entity new_fun)
{
  //printf("new HRE module\n");
  //print_statement(stat);
 
  reset_current_module_entity();
 
  set_current_module_entity(module_name_to_entity(module_name));
 
  entity cloned = get_current_module_entity();
  const char* name = entity_local_name(cloned);
  const char* new_name;
  string comments;
  //entity new_fun;
  //statement stat;
  bool saved_b1, saved_b2;
  text t;
    
  /* builds some kind of module / statement for the clone.
   */
  new_name = new_module_name;
  //new_fun = make_empty_subroutine(new_name);
 
  saved_b1 = get_bool_property(ALL_DECLS);
  saved_b2 = get_bool_property(STAT_ORDER);
  set_bool_property(ALL_DECLS, true);
  set_bool_property(STAT_ORDER, false);
 
  //stat = comEngine_generate_HRECode(externalized_code, new_fun, l_in, l_out);
 
  //add_variables_to_module(l_params, l_priv,
  //              new_fun, stat);
 
  move_declarations(new_fun, stat);
 
  reset_current_module_entity();
 
  set_current_module_entity(module_name_to_entity(module_name));
 
  t = text_named_module(new_fun, cloned, stat);
 
  set_bool_property(ALL_DECLS, saved_b1);
  set_bool_property(STAT_ORDER, saved_b2);
 
  /* add some comments before the code.
   */
  comments = strdup(concatenate(
                                "//\n"
                                "// PIPS: please caution!\n"
                                "//\n"
                                "// this routine has been generated as a clone of ", name, "\n"
                                "// the code may change significantly with respect to the original\n"
                                "// version, especially after program transformations such as dead\n"
                                "// code elimination and partial evaluation, hence the function may\n"
                                "// not have the initial behavior, if called under some other context.\n"
                                "//\n", 0));
  text_sentences(t) = 
    CONS(SENTENCE, make_sentence(is_sentence_formatted, comments),
         text_sentences(t));
  
  make_text_resource_and_free(new_name, DBR_C_SOURCE_FILE, ".c", t);
  free_statement(stat);
 
  /* give the clonee a user file.
   */
  DB_PUT_MEMORY_RESOURCE(DBR_USER_FILE, new_name, 
                         strdup(db_get_memory_resource(DBR_USER_FILE, name, true)));
 
}
 
/*static void
create_HRE_modules(statement externalized_code,
                  string new_module_name,
                  list l_in, list l_out, list l_params, list l_priv,
                  const char* module_name, int hreMemSize)
{
}
*/
static void comEngine_distribute_code (const char* module_name,
                                       string function_name,
                                       statement externalized_code, 
                                       list l_in,
                                       list l_out,
                                       list l_params,
                                       list l_priv,
                                       graph dg) 
{
  bool success = false;
 
  gLoopToRef = hash_table_make(hash_pointer, 0);
  gStatToRef = hash_table_make(hash_pointer, 0);
  gRefToEff = hash_table_make(hash_pointer, 0);
  gLoopToSync = hash_table_make(hash_pointer, 0);
  gLoopToSupRef = hash_table_make(hash_pointer, 0);
  gLoopToUnSupRef = hash_table_make(hash_pointer, 0);
  gRefToFifo = hash_table_make(hash_pointer, 0);
  gRefToFifoOff = hash_table_make(hash_pointer, 0);
  gRefToHREFifo = hash_table_make(hash_pointer, 0);
  gStatToHtOffset = hash_table_make(hash_pointer, 0);
  gRefToBuffSize = hash_table_make(hash_pointer, 0);
  gIndToNum = hash_table_make(hash_pointer, 0);
  gRefToInd = hash_table_make(hash_pointer, 0);
  gLoopToToggleEnt = hash_table_make(hash_pointer, 0);
  gEntToHREFifo = hash_table_make(hash_pointer, 0);
  gRefToToggle = hash_table_make(hash_pointer, 0);
  gToggleToInc = hash_table_make(hash_pointer, 0);
  gIsNewLoop = hash_table_make(hash_pointer, 0);
 
  statement procCode;
 
  success = comEngine_feasability(externalized_code, dg);
 
  if(success)
    {
      printf("distribution can be done\n");
    }
  else
    {
      printf("distribution cannot be done\n");
      return;
    }
 
  int hreMemSize = 512;
 
  success = compute_HRE_memory_mapping(externalized_code, hreMemSize);
 
  if(success)
    {
      printf("mapping is successful\n");
    }
  else
    {
      printf("mapping is not successful\n");
      return;
    }
 
  procCode = comEngine_generate_procCode(externalized_code, l_in, l_out);
 
  comEngine_generate_HRECode(externalized_code,
                             function_name,
                             l_in, l_out, l_params, l_priv,
                             module_name, hreMemSize);
 
printf("mapping is not successful 1\n");
  free_instruction(statement_instruction(externalized_code));
printf("comEngine_distribute_code 2\n");
  statement_instruction(externalized_code) = 
    statement_instruction(procCode);
printf("comEngine_distribute_code 3\n");
printf("comEngine_distribute_code 4\n");
  statement_comments(externalized_code) = string_undefined;
  statement_number(externalized_code) = STATEMENT_NUMBER_UNDEFINED;
  statement_label(externalized_code) = entity_empty_label();
printf("comEngine_distribute_code 5\n");
 
 HASH_MAP(loop, lEnt,
 {
   gen_free_list(lEnt);
   lEnt = NIL;
 }, gLoopToToggleEnt);
 
  printf("comEngine_distribute_code 8\n");
  hash_table_free(gLoopToRef);
  hash_table_free(gStatToRef);
  hash_table_free(gRefToEff);
  hash_table_free(gLoopToSync);
  hash_table_free(gLoopToSupRef);
  hash_table_free(gLoopToUnSupRef);
  free_expression(gBufferSizeEnt);
  hash_table_free(gRefToFifo);
  hash_table_free(gRefToFifoOff);
  hash_table_free(gRefToHREFifo);
  hash_table_free(gStatToHtOffset);
  hash_table_free(gRefToBuffSize);
  hash_table_free(gIndToNum);
  hash_table_free(gRefToInd);
  hash_table_free(gLoopToToggleEnt);
  hash_table_free(gEntToHREFifo);
  hash_table_free(gRefToToggle);
  hash_table_free(gToggleToInc);
  hash_table_free(gIsNewLoop);
 
}
 
void comEngine_distribute (const char* module_name, 
                           statement module_stat, 
                           entity module) 
{
  list l_stats;
  hash_table ht_stats;
  hash_table ht_params;
  hash_table ht_private;
  hash_table ht_in_regions;
  hash_table ht_out_regions;
 
  graph dg = (graph) db_get_memory_resource(DBR_DG, module_name, true);
 
  l_stats = identify_analyzed_statements_to_distribute (module_stat);
 
  compute_distribution_context (l_stats, 
                                module_stat,
                                module,
                                &ht_stats,
                                &ht_params,
                                &ht_private,
                                &ht_in_regions,
                                &ht_out_regions);
  
  HASH_MAP (function_name, stat, {
      comEngine_distribute_code (module_name,
                                 function_name,
                                 stat, 
                                 hash_get(ht_in_regions,function_name),
                                 hash_get(ht_out_regions,function_name),
                                 hash_get(ht_params,function_name),
                                 hash_get(ht_private,function_name),
                                 dg);
  },ht_stats);
  
  hash_table_free(ht_stats);
  hash_table_free(ht_params);
  hash_table_free(ht_private);
  hash_table_free(ht_in_regions);
  hash_table_free(ht_out_regions);
}
 
bool phrase_comEngine_distributor(const char* module_name)
{
  statement module_stat;
  entity module;
 
  entity dynamic_area = entity_undefined;
 
  // set and get the current properties concerning regions 
  set_bool_property("MUST_REGIONS", true);
  set_bool_property("EXACT_REGIONS", true);
  get_regions_properties();
  
  // get the resources 
  module_stat = (statement) db_get_memory_resource(DBR_CODE, 
                                                   module_name, 
                                                   true);
  
  module = module_name_to_entity(module_name);
  
  set_current_module_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name)); // FI: a bit redundant since module is already available
  
  set_cumulated_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_proper_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  module_to_value_mappings(module);
  
  // sets dynamic_area 
  if (entity_undefined_p(dynamic_area)) {       
    dynamic_area = FindOrCreateEntity(module_local_name(module),
                                      DYNAMIC_AREA_LOCAL_NAME); 
  }
 
  debug_on("PHRASE_COMENGINE_DISTRIBUTOR_DEBUG_LEVEL");
 
    // Get the READ, WRITE, IN and OUT regions of the module
    set_rw_effects((statement_effects) 
        db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_in_effects((statement_effects) 
        db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
    set_out_effects((statement_effects) 
        db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
 
  // Now do the job
 
  pips_debug(2, "BEGIN of PHRASE_DISTRIBUTOR\n");
  comEngine_distribute(module_name, module_stat, module);
  pips_debug(2, "END of PHRASE_DISTRIBUTOR\n");
 
  //print_statement(module_stat);
 
  pips_assert("Statement structure is consistent after PHRASE_DISTRIBUTOR", 
              gen_consistent_p((gen_chunk*)module_stat));
              
  pips_assert("Statement is consistent after PHRASE_DISTRIBUTOR", 
              statement_consistent_p(module_stat));
  
  // Reorder the module, because new statements have been added  
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, 
                         compute_callees(module_stat));
  
  // update/release resources 
  reset_current_module_statement();
  reset_current_module_entity();
  dynamic_area = entity_undefined;
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  free_value_mappings();
  
  debug_off();
  
  return true;
}