print.c

Go to the documentation of this file.

/*
 
  $Id: print.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
 
/* Name     : print.c
 * Package  : prgm_mapping
 * Author   : Alexis Platonoff
 * Date     : septembre 1993
 *
 * Historic :
 * - 23 sept 93, creation, AP
 *
 * Documents:
 * Comments : This file contains the functions used for printing the data
 * structures used for prgm_mapping.
 */
 
/* Ansi includes        */
#include <stdio.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 "matrice.h"
#include "matrix.h"
 
/* Pips includes        */
#include "ri.h"
#include "ri-util.h"
#include "constants.h"
#include "misc.h"
#include "graph.h"
#include "paf_ri.h"
#include "text.h"
#include "text-util.h"
#include "misc.h"
#include "paf-util.h"
 
/* Macro functions      */
 
/* Global variables     */
 
/* Internal variables   */
 
/* Local defines */
typedef dfg_vertex_label vertex_label;
typedef dfg_arc_label arc_label;
 
 
/* ======================================================================== */
void fprint_plc(fp, obj)
FILE *fp;
plc obj;
{
  placement func;
  list funcs, dims, d;
  int stmt;
 
  fprintf(fp, "\nPROGRAM MAPPING :\n================= \n");
 
  for(funcs = plc_placements(obj); funcs != NIL; funcs = CDR(funcs)) {
    func = PLACEMENT(CAR(funcs));
    stmt = placement_statement(func);
    dims = placement_dims(func);
 
    /* Mod by AP, oct 6th 95: the number of the instruction is the
       vertex number minus BASE_NODE_NUMBER. */
    fprintf(fp, "Ins_%d :", stmt-BASE_NODE_NUMBER);
 
    for(d = dims; d != NIL; d = CDR(d)) {
      expression exp = EXPRESSION(CAR(d));
      fprintf(fp, "%s", expression_to_string(exp));
      if(CDR(d) == NIL)
        fprintf(fp, "\n");
      else
        fprintf(fp, " , ");
    }
  }
  fprintf(fp, "\n");
}
 
 
/* ======================================================================== */
void plc_fprint_proto(fp, g, StmtToProto)
FILE *fp;
graph g;
hash_table StmtToProto;
{
 
 list l;
 
 /* For each node of the data flow graph we print its prototype. */
 for(l = graph_vertices(g); l != NIL; l = CDR(l))
   {
    vertex v = VERTEX(CAR(l));
    int stmt = dfg_vertex_label_statement((dfg_vertex_label) vertex_vertex_label(v));
 
    Ppolynome pp_proto = (Ppolynome) hash_get(StmtToProto, (char *) stmt);
 
    /* Print */
    fprintf(fp, "ins_%d: ",  stmt);
    polynome_fprint(fp, pp_proto, entity_local_name, pu_is_inferior_var);
    fprintf(fp, "\n");
   }
}
 
 
/* ======================================================================== */
void plc_fprint_distance(fp, g, DtfToDist)
FILE *fp;
graph g;
hash_table DtfToDist;
{
  Ppolynome pp_dist;
  list l, su_l, df_l;
 
  for(l = graph_vertices(g); l != NIL; l = CDR(l)) {
    vertex v = VERTEX(CAR(l));
 
    fprintf(fp, "source stmt: %d\n", vertex_int_stmt(v));
 
    su_l = vertex_successors(v);
 
    for( ; su_l != NIL; su_l = CDR(su_l)) {
      successor su = SUCCESSOR(CAR(su_l));
      int sink_stmt = vertex_int_stmt(successor_vertex(su));
 
      df_l = dfg_arc_label_dataflows((dfg_arc_label) successor_arc_label(su));
 
      for( ; df_l != NIL; df_l = CDR(df_l)) {
        dataflow df = DATAFLOW(CAR(df_l));
 
        fprint_dataflow(fp, sink_stmt, df);
 
        pp_dist = (Ppolynome) hash_get(DtfToDist, (char *) df);
 
        fprintf(fp, "DF Dist:");
        polynome_fprint(fp, pp_dist, pu_variable_name, pu_is_inferior_var);
        fprintf(fp, "\n");
      }
    }
  }
}
 
 
/* ======================================================================== */
void plc_fprint_dfs(fp, df_l, DtfToStmt, DtfToWgh)
FILE *fp;
list df_l;
hash_table DtfToWgh, DtfToStmt;
{
 list l = df_l;
 
 fprintf(fp, "Listes triee des flots de donnees :\n");
 
 for( ; l != NIL; l = CDR(l))
   {
    dataflow df = DATAFLOW(CAR(l));
    fprintf(fp, "Poids %d ***", (int) hash_get(DtfToWgh, (char *) df));
    fprint_dataflow(fp, (int) hash_get(DtfToStmt, (char *) df), df);
   }
  fprintf(fp, "\n");
}
 
 
/* ======================================================================== */
/*
 * void fprint_pla_pp_dims(fp, one_placement)
 */
void fprint_pla_pp_dims(fp, one_placement)
FILE *fp;
placement one_placement;
{
  list plc_dims =  placement_dims(one_placement);
  int count = 1;
 
  fprintf(fp, "\nBroadcast Mapping for %d :\n",
          placement_statement(one_placement));
 
  for(; !ENDP(plc_dims); POP(plc_dims), count++) {
    Ppolynome crt_pp = (Ppolynome) CHUNK(CAR(plc_dims));
 
    fprintf(fp, "Dim %d :", count);
    polynome_fprint(stderr, crt_pp, pu_variable_name, pu_is_inferior_var);
    fprintf(fp, "\n");
  }
}
 
 
/* ======================================================================== */
/*
 * void fprint_plc_pp_dims(fp, one_plc)
 */
void fprint_plc_pp_dims(fp, one_plc)
FILE *fp;
plc one_plc;
{
  list pla_l = plc_placements(one_plc);
 
  fprintf(fp, "\nBROADCAST PROGRAM MAPPING :\n===========================\n");
 
  for(; !ENDP(pla_l); POP(pla_l)) {
    placement crt_pla = PLACEMENT(CAR(pla_l));
    fprint_pla_pp_dims(fp, crt_pla);
  }
}