comEngine_optimization_function.c

Go to the documentation of this file.

/*
 
  $Id: comEngine_optimization_function.c 23495 2018-10-24 09:19:47Z coelho $
 
  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 "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 "phrase.h"
 
hash_table gLoopToOpt;
 
static list glSeqs = NIL;
static list glStats = NIL;
 
static void opt_loop_interchange_fill_lists_stat(statement stat)
{
  glStats = gen_nconc(glStats, CONS(STATEMENT, stat, NIL));
}
 
static void opt_loop_interchange_fill_lists(statement stat)
{
  void* bIsNewLoop = hash_get(gIsNewLoop, stat);
 
  if(bIsNewLoop != HASH_UNDEFINED_VALUE)
    {
      if(glStats != NIL)
        {
          printf("put glSeqs 1\n");
          MAP(STATEMENT, curStat,
          {
            print_statement(curStat);
          }, glStats);
 
          glSeqs = gen_nconc(glSeqs, CONS(LIST, glStats, NIL));
 
          glStats = NIL;
        }
 
      printf("put glSeqs 2\n");
      print_statement(stat);
 
      glSeqs = gen_nconc(glSeqs, CONS(LIST, CONS(STATEMENT, stat, NIL), NIL));
 
      return;
    }
 
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_sequence:
      {
        MAP(STATEMENT, curStat,
        {
          opt_loop_interchange_fill_lists(curStat);
 
        }, sequence_statements(instruction_sequence(instr)));
        break;
      }
      /*case is_instruction_loop:
      {
        //opt_loop_interchange_fill_lists_loop(stat);
        break;
        }*/
    case is_instruction_call:
    case is_instruction_test:
      {
        opt_loop_interchange_fill_lists_stat(stat);
        break;
      }
    default:
      {
        pips_internal_error("impossible");
        break;
      }
    }
}
 
static statement make_loopPattern(statement innerStat)
{
  loop curLoop = statement_loop(innerStat);
 
  range newRange = copy_range(loop_range(curLoop));
 
  loop newLoop = make_loop(loop_index(curLoop),
                           newRange,
                           statement_undefined,
                           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(newLoop),NIL,NULL,
                        empty_extensions (), make_synchronization_none());
}
 
static entity gIndEnt = entity_undefined;
 
static void entity_in_stat_rwt(reference curRef, bool * entInStat)
{
  if(reference_variable(curRef) == gIndEnt)
    {
      *entInStat = true;
    }
}
 
static bool entity_in_stat(entity ind, statement stat)
{
  bool entInStat = false;
  gIndEnt = ind;
 
  gen_context_recurse(stat, &entInStat,
    reference_domain, gen_true2, entity_in_stat_rwt);
 
  return entInStat;
}
 
static void move_statements_stat(statement stat, entity ind,
                                 list * lInBody, list * lOutBody)
{
  if(entity_in_stat(ind, stat) ||
     statement_loop_p(stat))
    {
      *lInBody = gen_nconc(*lInBody, 
                           CONS(STATEMENT, copy_statement(stat), NIL));
    }
  else
    {
      *lOutBody = gen_nconc(*lOutBody,
                            CONS(STATEMENT, copy_statement(stat), NIL));
    }
}
 
static void move_statements(statement stat, entity ind,
                            list * lInBody, list * lOutBody)
{
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_sequence:
      {
        MAP(STATEMENT, curStat,
        {
          move_statements(curStat, ind, lInBody, lOutBody);
 
        }, sequence_statements(instruction_sequence(instr)));
        break;
      }
    case is_instruction_loop:
    case is_instruction_call:
    case is_instruction_test:
      {
        move_statements_stat(stat, ind, lInBody, lOutBody);
        break;
      }
    default:
      {
        pips_internal_error("impossible");
        break;
      }
    }
}
 
static entity gSearchedEnt = entity_undefined;
static bool gEntFound = false;
 
static void entity_in_ref_rwt(reference curRef)
{
  printf("entity_in_ref_rwt\n");
  print_reference(curRef);printf("\n");
  if(reference_variable(curRef) == gSearchedEnt)
    {
      gEntFound = true;
    }
}
 
static bool entity_in_ref(entity ent, reference ref)
{
  gSearchedEnt = ent;
  gEntFound = false;
 
  printf("entity_in_ref\n");
  print_entity_variable(ent);
  print_reference(ref);printf("\n");
 
  gen_recurse(ref, reference_domain, gen_true, entity_in_ref_rwt);
 
  if(gEntFound)
    {
      printf("found\n");
    }
  else
    {
      printf("not found\n");
    }
 
  return gEntFound;
}
 
static void regenerate_toggles(statement stat, statement newStat,
                               list * lInBody)
{
  //printf("regenerate_toggles\n");
  //print_statement(stat);
 
  list lToggleEnt = hash_get(gLoopToToggleEnt, newStat);
 
  if(lToggleEnt == HASH_UNDEFINED_VALUE)
    {
      return;
    }
 
  statement tempStat = make_block_statement(*lInBody);
 
  list lIncStats = NIL;
  list lMmcdStats = NIL;
 
  FOREACH(ENTITY, oldTog,lToggleEnt)
  {
    printf("oldTog\n");
    print_entity_variable(oldTog);
 
    entity newTog =
      comEngine_make_new_scalar_variable(strdup("toggle"),
                                         make_basic(is_basic_int, (void *)4));
      AddEntityToCurrentModule(newTog);
 
    comEngine_replace_reference_in_stat(tempStat,
                                        make_reference(oldTog, NIL),
                                        entity_to_expression(newTog));
 
    intptr_t inc = (intptr_t)hash_get(gToggleToInc, oldTog);
 
    pips_assert("inc != HASH_UNDEFINED_VALUE",
                inc != (intptr_t)HASH_UNDEFINED_VALUE);
 
    statement incStat = make_toggle_inc_statement(newTog, inc);
 
    lIncStats = gen_nconc(lIncStats, CONS(STATEMENT, incStat, NIL));
 
    list lRef = NIL;
    HASH_MAP(ref1, tog1,
    {
      if((entity)tog1 == oldTog)
        {
          if(entity_in_ref(loop_index(statement_loop(stat)),
                           ref1))
            {
              lRef = CONS(REFERENCE, ref1, lRef);
            }
        }
    }, gRefToToggle);
 
    MAP(REFERENCE, ref1,
    {
      hash_put(gRefToToggle, ref1, newTog);
    }, lRef);
    gen_free_list(lRef);
 
    statement mmcdStat = make_toggle_mmcd(newTog);
 
    lMmcdStats = gen_nconc(lMmcdStats, CONS(STATEMENT, mmcdStat, NIL));
 
    statement initStat = make_toggle_init_statement(newTog);
 
    glToggleInitStats = gen_nconc(glToggleInitStats, CONS(STATEMENT, initStat, NIL));
 
  } 
 
  instruction_block(statement_instruction(tempStat)) = NIL;
 
  free_statement(tempStat);
 
  *lInBody = gen_nconc(lMmcdStats, *lInBody);
  *lInBody = gen_nconc(*lInBody, lIncStats);
}
 
static statement make_seqStat(statement stat, statement loopPattern,
                              list oldCurList, entity newInd)
{
  pips_assert("true", newInd==newInd);
  statement tempStat = STATEMENT(CAR(oldCurList));
 
  void* bIsNewLoop = hash_get(gIsNewLoop, tempStat);
 
  if(bIsNewLoop == HASH_UNDEFINED_VALUE)
    {
      statement seqStat = copy_statement(loopPattern);
 
      loop_body(statement_loop(seqStat)) = make_block_statement(oldCurList);
 
      return seqStat;
    }
 
  statement saveStat = statement_undefined;
 
  MAP(STATEMENT, curStat,
  {
    if(statement_loop_p(curStat))
      {
        saveStat = curStat;
      }
  }, statement_block(tempStat));
 
  pips_assert("saveStat != statement_undefined",
              saveStat != statement_undefined);
 
  list curList = gen_full_copy_list(oldCurList);
 
  tempStat = STATEMENT(CAR(curList));
 
  statement seqStat = statement_undefined;// = STATEMENT(CAR(curList));
 
  pips_assert("statement_block_p(tempStat)", statement_block_p(tempStat));
 
  MAP(STATEMENT, curStat,
  {
    if(statement_loop_p(curStat))
      {
        seqStat = curStat;
      }
  }, statement_block(tempStat));
 
  pips_assert("seqStat != statement_undefined",
              seqStat != statement_undefined);
 
  gen_free_list(curList);
 
  statement inLoop = copy_statement(loopPattern);
 
  list lOutBody = NIL;
  list lInBody = NIL;
 
  move_statements(loop_body(statement_loop(seqStat)),
                  loop_index(statement_loop(loopPattern)),
                  &lInBody, &lOutBody);
 
  free_statement(loop_body(statement_loop(seqStat)));
 
  /*statement stepStat =
    make_loop_step_stat(inLoop,
                        loop_index(statement_loop(loopPattern)));
 
  lInBody = gen_nconc(CONS(STATEMENT, stepStat, NIL), lInBody);
  */
 
  regenerate_toggles(stat, saveStat, &lInBody);
 
  loop_body(statement_loop(inLoop)) = make_block_statement(lInBody);
 
  lOutBody = gen_nconc(lOutBody, CONS(STATEMENT, inLoop, NIL));
 
  loop_body(statement_loop(seqStat)) = make_block_statement(lOutBody);
 
  return tempStat;
}
 
statement comEngine_opt_loop_interchange(statement stat, statement innerStat,
                                         entity newInd)
{
  printf("comEngine_opt_loop_interchange\n");
  print_statement(innerStat);
 
  pips_assert("innerStat is a loop statement", statement_loop_p(innerStat));
 
  statement body = loop_body(statement_loop(innerStat));
 
  if(!statement_block_p(body))
    {
      return innerStat;
    }
 
  printf("stat\n");
  print_statement(stat);
 
  bool allowedOpt = (intptr_t)hash_get(gLoopToOpt, stat);
 
  pips_assert("allowedOpt != HASH_UNDEFINED_VALUE",
              allowedOpt != (intptr_t)HASH_UNDEFINED_VALUE);
 
  if(!allowedOpt)
    {
      printf("opt not all\n");
      return innerStat;
    }
  else
    {
      printf("opt all\n");
    }
 
  glSeqs = NIL;
  glStats = NIL;
 
  opt_loop_interchange_fill_lists(body);
 
  if(glStats != NIL)
    {
          printf("put glSeqs 3\n");
          MAP(STATEMENT, curStat,
          {
            print_statement(curStat);
          }, glStats);
 
      glSeqs = gen_nconc(glSeqs, CONS(LIST, glStats, NIL));
 
      glStats = NIL;
    }
 
  list lStats = NIL;
  statement loopPattern = make_loopPattern(innerStat);
 
  //printf("glSeqs\n");
  MAP(LIST, curList,
  {
  /*
    //printf("glSeqs it 1\n");
    MAP(STATEMENT, curStat,
    {
      //printf("glSeqs it 2\n");
      //print_statement(curStat);
      //printf("glSeqs it 2 end\n");
 
    }, curList);
    */
 
    statement seqStat = make_seqStat(stat, loopPattern, curList, newInd);
 
    lStats = gen_nconc(lStats, CONS(STATEMENT, seqStat, NIL));
 
  }, glSeqs);
 
  gen_free_list(glSeqs);
 
  free_statement(loopPattern);
 
  printf("bef 2\n");
  loop_body(statement_loop(innerStat)) = statement_undefined;
  printf("aft 2\n");
 
  free_statement(innerStat);
 
  statement newStat = make_block_statement(lStats);
 
  printf("comEngine_opt_loop_interchange newStat\n");
  print_statement(newStat);
 
  return newStat;
}