prettyprint.c

Go to the documentation of this file.

/*
 
  $Id: prettyprint.c 23065 2016-03-02 09:05:50Z 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
/* Ansi includes        */
#include <stdio.h>
#include <string.h>
 
/* Newgen includes      */
#include "genC.h"
 
/* C3 includes          */
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "union.h"
#include "matrix.h"
 
/* Pips includes        */
#include "boolean.h"
#include "ri.h"
#include "constants.h"
#include "ri-util.h"
#include "misc.h"
#include "complexity_ri.h"
#include "database.h"
#include "graph.h"
#include "dg.h"
#include "paf_ri.h"
#include "parser_private.h"
#include "property.h"
#include "properties.h"
#include "prettyprint.h"
#include "reduction.h"
#include "text.h"
#include "text-util.h"
#include "tiling.h"
#include "text-util.h"
#include "pipsdbm.h"
#include "resources.h"
#include "static_controlize.h"
#include "paf-util.h"
#include "pip.h"
#include "array_dfg.h"
#include "prgm_mapping.h"
#include "reindexing.h"
 
#define CM_FORTRAN_EXT ".fcm"
#define CRAFT_FORTRAN_EXT ".craft"
 
/* Local defines */
typedef dfg_vertex_label vertex_label;
typedef dfg_arc_label arc_label;
 
extern list lparams;
static graph current_dfg;
static bdt current_bdt;
 
 
/*=======================================================================*/
/* statement make_layout_statement(entity ae, int serial, news):
 * 
 */
 
statement make_layout_statement(ae, serial, news)
     entity ae;
     int serial, news;
{
  instruction  ins;
  list         lstat = NIL;
  char         *comment;
  statement    stat;
  int i;
 
  comment = (char*) malloc(64);
  sprintf(comment,"CMF$  LAYOUT %s(", entity_local_name(ae));
  for(i = 0; i < serial; i++) { 
    sprintf(comment, "%s:SERIAL", comment); 
    if((i < serial-1) || ((i == serial-1) && (news > 0)) ) 
      sprintf(comment, "%s, ", comment);
  } 
  for(i = 0; i < news; i++) { 
    sprintf(comment, "%s:NEWS", comment); 
    if(i < news-1)
      sprintf(comment, "%s, ", comment);
  } 
  sprintf(comment, "%s)\n", comment);
 
  stat = make_nop_statement();
  insert_comments_to_statement(stat, comment);
  lstat = CONS(STATEMENT, stat, lstat);
 
  /* put all the pieces of lstat in one statement */
  stat = make_block_statement(lstat);
 
  if(get_debug_level() > 1)
    fprintf(stderr, 
            "\nmake_layout_statement\n=====================\n%s\n", 
            comment); 
 
  return(stat);
}
  
 
/*=======================================================================*/
/* statement make_shared_statement(entity ae, int serial, news):
 * 
 */
 
statement make_shared_statement(ae, serial, news)
     entity ae;
     int serial, news;
{
  instruction  ins;
  list         lstat = NIL;
  char         *comment;
  statement    stat;
  int i;
 
  comment = (char*) malloc(64);
  sprintf(comment,"CDIR$ SHARED %s(", entity_local_name(ae));
  for(i = 0; i < serial; i++) { 
    sprintf(comment, "%s:", comment); 
    if((i < serial-1) || ((i == serial-1) && (news > 0)) ) 
      sprintf(comment, "%s, ", comment);
  } 
  for(i = 0; i < news; i++) { 
    sprintf(comment, "%s:BLOCK", comment); 
    if(i < news-1)
      sprintf(comment, "%s, ", comment);
  } 
  sprintf(comment, "%s)\n", comment);
 
  stat = make_nop_statement();
  insert_comments_to_statement(stat, comment);
  lstat = CONS(STATEMENT, stat, lstat);
 
  /* put all the pieces of lstat in one statement */
  stat = make_block_statement(lstat);
 
  if(get_debug_level() > 1)
    fprintf(stderr, 
            "\nmake_shared_statement\n=====================\n%s\n", 
            comment); 
 
  return(stat);
}
  
 
/*=======================================================================*/
/* void cmf_layout_align(statement mod_stat):
 * 
 */
 
void cmf_layout_align(mod_stat)
     statement mod_stat;
{
  list list_body, list_la, lae = NIL, li = NIL, lv;
 
  for(lv = graph_vertices(current_dfg); !ENDP(lv); POP(lv)) {
    vertex cv;
    int cn, bdim;
    list bv, ciel;
    string name;
    char num[32];
    entity array_ent;
    static_control stco;
 
    cv = VERTEX(CAR(lv));
    cn = dfg_vertex_label_statement(vertex_vertex_label(cv));
 
    if (cn == ENTRY_ORDER)
      continue;
    if (cn == EXIT_ORDER)
      continue;
 
    /* Static control of the node */
    stco = get_stco_from_current_map(adg_number_to_statement(cn));
 
    ciel = static_control_to_indices(stco);
 
    if(get_debug_level() > 0) {
      fprintf(stderr, "\nIn cmf_layout_align, CIEL : ");
      fprint_entity_list(stderr, ciel);
    }
 
    /* We extract the bdt corresponding to this node. */
    bv = extract_bdt(current_bdt, cn);
 
    /* We count the number of non constant dimension for each
       domain. */
    bdim = 0;
    for (; !ENDP(bv); POP(bv)) { 
      int bcount = 0; 
      schedule sched = SCHEDULE(CAR(bv)); 
      list lexp; 
      
      for (lexp = schedule_dims(sched); !ENDP(lexp); POP(lexp)) { 
        expression exp = EXPRESSION(CAR(lexp)); 
        normalized nor = NORMALIZE_EXPRESSION(exp); 
        
        if(normalized_tag(nor) == is_normalized_linear) { 
          Pvecteur vec = normalized_linear(expression_normalized(exp)); 
          
          if (vars_in_vect_p(vec, ciel)) 
            bcount++; 
        } 
        else 
          user_error("cmf_layout_align", 
                     "Rational case not treated yet !"); 
      } 
 
      if(bcount > bdim) 
        bdim = bcount; 
    }
    li = CONS(INT, bdim, li);
 
    /* We get the array entity corresponding to this node. */
    (void) sprintf(num, "%d", cn-BASE_NODE_NUMBER);
    name = (string) strdup(concatenate(SA_MODULE_NAME, MODULE_SEP_STRING,
                                       SAI, num, (string) NULL));
    array_ent = gen_find_tabulated(name, entity_domain);
    if(array_ent == entity_undefined)
      user_error("make_array_bounds",
                 "\nOne ins (%d) has no array entity : %s\n",
                 cn-BASE_NODE_NUMBER, name);
 
    lae = CONS(ENTITY, array_ent, lae);
  }
 
  /* Layout */
  list_la = NIL;
  for(; !ENDP(lae); POP(lae), POP(li)) {
    entity ae;
    int serial, nb_dims, news;
 
    ae = ENTITY(CAR(lae));
    serial = INT(CAR(li));
    nb_dims =
      gen_length(variable_dimensions(type_variable(entity_type(ae))));
    news = nb_dims - serial;
 
    list_la = CONS(STATEMENT, make_layout_statement(ae, serial, news),
                   list_la);
  }
 
  /* We add these declarations to the statement of the module */
  /* After reindexing, the first statement is in fact a sequence and
     no longer an unstructured. Trust it to simplify the following: */
  if(instruction_tag(statement_instruction(mod_stat)) !=
     is_instruction_sequence)
    pips_user_error("Body is not a block\n");
 
  list_body = gen_nconc(list_la,
                        sequence_statements(instruction_sequence(statement_instruction(mod_stat))));
  sequence_statements(instruction_sequence(statement_instruction(mod_stat))) =
      list_body;
}
 
 
/*=======================================================================*/
/* void craft_layout_align(statement mod_stat):
 * 
 */
 
void
craft_layout_align(statement mod_stat)
{
  list list_body, list_la, lae = NIL, li = NIL, lv;
 
  for(lv = graph_vertices(current_dfg); !ENDP(lv); POP(lv)) {
    vertex cv;
    int cn, bdim;
    list bv, ciel;
    string name;
    char num[32];
    entity array_ent;
    static_control stco;
 
    cv = VERTEX(CAR(lv));
    cn = dfg_vertex_label_statement(vertex_vertex_label(cv));
 
    if (cn == ENTRY_ORDER)
      continue;
    if (cn == EXIT_ORDER)
      continue;
 
    /* Static control of the node */
    stco = get_stco_from_current_map(adg_number_to_statement(cn));
 
    ciel = static_control_to_indices(stco);
 
    if(get_debug_level() > 0) {
      fprintf(stderr, "\nIn craft_layout_align, CIEL : ");
      fprint_entity_list(stderr, ciel);
    }
 
    /* We extract the bdt corresponding to this node. */
    bv = extract_bdt(current_bdt, cn);
 
    /* We count the number of non constant dimension for each
       domain. */
    bdim = 0;
    for (; !ENDP(bv); POP(bv)) { 
      int bcount = 0; 
      schedule sched = SCHEDULE(CAR(bv)); 
      list lexp; 
      
      for (lexp = schedule_dims(sched); !ENDP(lexp); POP(lexp)) { 
        expression exp = EXPRESSION(CAR(lexp)); 
        normalized nor = NORMALIZE_EXPRESSION(exp); 
        
        if(normalized_tag(nor) == is_normalized_linear) { 
          Pvecteur vec = normalized_linear(expression_normalized(exp)); 
          
          if (vars_in_vect_p(vec, ciel)) 
            bcount++; 
        } 
        else 
          user_error("craft_layout_align", 
                     "Rational case not treated yet !"); 
      } 
 
      if(bcount > bdim) 
        bdim = bcount; 
    }
    li = CONS(INT, bdim, li);
 
    /* We get the array entity corresponding to this node. */
    (void) sprintf(num, "%d", cn-BASE_NODE_NUMBER);
    name = (string) strdup(concatenate(SA_MODULE_NAME, MODULE_SEP_STRING,
                                       SAI, num, (string) NULL));
    array_ent = gen_find_tabulated(name, entity_domain);
    if(array_ent == entity_undefined)
      user_error("craft_layout_align",
                 "\nOne ins (%d) has no array entity : %s\n",
                 cn-BASE_NODE_NUMBER, name);
 
    lae = CONS(ENTITY, array_ent, lae);
  }
 
  /* Shared */
  list_la = NIL;
  for(; !ENDP(lae); POP(lae), POP(li)) {
    entity ae;
    int serial, nb_dims, news;
 
    ae = ENTITY(CAR(lae));
    serial = INT(CAR(li));
    nb_dims =
      gen_length(variable_dimensions(type_variable(entity_type(ae))));
    news = nb_dims - serial;
 
    list_la = CONS(STATEMENT, make_shared_statement(ae, serial, news),
                   list_la);
  }
 
  /* We add these declarations to the statement of the module */
  /* After reindexing, the first statement is in fact a sequence and
     no longer an unstructured. Trust it to simplify the following: */
  if(instruction_tag(statement_instruction(mod_stat)) !=
     is_instruction_sequence)
    pips_user_error("Body is not a block\n");
 
  list_body = gen_nconc(list_la,
                        sequence_statements(instruction_sequence(statement_instruction(mod_stat))));
  sequence_statements(instruction_sequence(statement_instruction(mod_stat))) =
      list_body;
  }
 
 
/*=======================================================================*/
bool print_parallelizedCMF_code(mod_name)
char *mod_name;
{
  plc the_plc;
 
  text r = make_text(NIL);
  entity module;
  statement mod_stat;
  code c;
  string s, pp;
  static_control stco;
  statement_mapping STS;
  bool success;
 
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  
  module = local_name_to_top_level_entity(mod_name);
  if (module != get_current_module_entity()) {
    reset_current_module_entity();
    set_current_module_entity(module);
  }
  c = entity_code(module);
  s = code_decls_text(c);
 
  /* Static controlize code */
  mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, true); 
  STS = (statement_mapping) db_get_memory_resource(DBR_STATIC_CONTROL, 
                                            mod_name, true); 
  set_current_stco_map(STS);
  stco = get_stco_from_current_map(mod_stat);
 
  lparams = static_control_params(stco); 
  if (stco == static_control_undefined)  
    pips_internal_error("This is an undefined static control !");  
  if (!static_control_yes(stco))  
    pips_internal_error("This is not a static control program !");  
  
  /* The DFG, the BDT and the PLC */
  current_dfg = adg_pure_dfg((graph) db_get_memory_resource(DBR_ADFG,
                                                        mod_name, true));
  current_bdt = (bdt) db_get_memory_resource(DBR_BDT, mod_name, true);
  the_plc = (plc) db_get_memory_resource(DBR_PLC, mod_name, true);
  if (get_debug_level() > 0) {
    fprint_dfg(stderr, current_dfg);
    fprint_bdt(stderr, current_bdt);
    fprint_plc(stderr, the_plc);
  }
 
  pp = strdup(get_string_property(PRETTYPRINT_PARALLEL));
  set_string_property(PRETTYPRINT_PARALLEL, "cmf");
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", true);
 
  init_prettyprint(empty_text);
 
  mod_stat = (statement)
    db_get_memory_resource(DBR_REINDEXED_CODE, mod_name, true);
    
  insure_declaration_coherency_of_module(module, mod_stat);
 
  cmf_layout_align(mod_stat);
 
  MERGE_TEXTS(r, text_module(module, mod_stat));
 
  success = make_text_resource(mod_name,
                               DBR_PARALLELPRINTED_FILE,
                               CM_FORTRAN_EXT,
                               r);
 
  reset_current_stco_map();
  reset_current_module_entity();
  close_prettyprint();
 
  set_string_property(PRETTYPRINT_PARALLEL, pp); free(pp);
 
  debug_off();
 
  return(success);
}
 
 
/*=======================================================================*/
bool print_parallelizedCRAFT_code(mod_name)
char *mod_name;
{
  plc the_plc;
 
  text r = make_text(NIL);
  entity module;
  statement mod_stat;
  code c;
  string s, pp;
  static_control stco;
  statement_mapping STS;
  bool success;
 
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  
  module = local_name_to_top_level_entity(mod_name);
  if (module != get_current_module_entity()) {
    reset_current_module_entity();
    set_current_module_entity(module);
  }
  c = entity_code(module);
  s = code_decls_text(c);
 
  /* Static controlize code */
  mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, true); 
  STS = (statement_mapping)db_get_memory_resource(DBR_STATIC_CONTROL, 
                                           mod_name, true); 
  set_current_stco_map(STS);
  stco = get_stco_from_current_map(mod_stat);
 
  lparams = static_control_params(stco); 
  if (stco == static_control_undefined)  
    pips_internal_error("This is an undefined static control !");  
  if (!static_control_yes(stco))  
    pips_internal_error("This is not a static control program !");  
  
  /* The DFG, the BDT and the PLC */
  current_dfg = adg_pure_dfg((graph) db_get_memory_resource(DBR_ADFG,
                                                            mod_name,
                                                            true));
  current_bdt = (bdt) db_get_memory_resource(DBR_BDT, mod_name, true);
  the_plc = (plc) db_get_memory_resource(DBR_PLC, mod_name, true);
  if (get_debug_level() > 0) {
    fprint_dfg(stderr, current_dfg);
    fprint_bdt(stderr, current_bdt);
    fprint_plc(stderr, the_plc);
  }
 
  pp = strdup(get_string_property(PRETTYPRINT_PARALLEL));
  set_string_property(PRETTYPRINT_PARALLEL, "craft");
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", true);
 
  init_prettyprint(empty_text);
 
  mod_stat = (statement) db_get_memory_resource(DBR_REINDEXED_CODE,
                                                mod_name, true);
    
  insure_declaration_coherency_of_module(module, mod_stat);
  craft_layout_align(mod_stat);
  MERGE_TEXTS(r, text_module(module, mod_stat));
 
  success = make_text_resource(mod_name,
                               DBR_PARALLELPRINTED_FILE,
                               CRAFT_FORTRAN_EXT,
                               r);
 
  reset_current_stco_map();
  reset_current_module_entity();
  close_prettyprint();
  set_string_property(PRETTYPRINT_PARALLEL, pp); free(pp);
  debug_off();
 
  return(success);
}