Open64: osprey/be/cg/orc_intel/sched

00001 /* -*-Mode: c++;-*- (Tell emacs to use c++ mode) */
00002 
00003 /*
00004  *  Copyright (C) 2000-2003, Intel Corporation
00005  *  All rights reserved.
00006  *  
00007  *  Redistribution and use in source and binary forms, with or without modification,
00008  *  are permitted provided that the following conditions are met:
00009  *  
00010  *  Redistributions of source code must retain the above copyright notice, this list
00011  *  of conditions and the following disclaimer. 
00012  *  
00013  *  Redistributions in binary form must reproduce the above copyright notice, this list
00014  *  of conditions and the following disclaimer in the documentation and/or other materials
00015  *  provided with the distribution. 
00016  *
00017  *  Neither the name of the owner nor the names of its contributors may be used to endorse or
00018  *  promote products derived from this software without specific prior written permission. 
00019  *
00020  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
00021  *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
00022  *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR
00023  *  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
00024  *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
00025  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00026  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00027  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00028  *
00029  */
00030 
00031  /* =========================================================================
00032   * =========================================================================
00033   * 
00034   * Module: sched_dump.h
00035   *
00036   * $Revision: 1.1.1.1 $
00037   * $Date: 2005/10/21 19:00:00 $
00038   * $Author: marcel $
00039   * $Source: /proj/osprey/CVS/open64/osprey1.0/be/cg/orc_intel/sched_dump.cxx,v $
00040   *
00041   * Description:
00042   * ============
00043   * 
00044   * Most of dump-routines implemented in this file. since dump routines 
00045   * are rarely used. We concentrate them in one place to reduce the working-
00046   * set of our compiler
00047   *
00048   * =========================================================================
00049   * =========================================================================
00050   */
00051 #include "defs.h"
00052 #include "tracing.h"
00053 #include "scheduler.h"
00054 #include "stdarg.h"
00055 #include "sched_rgn_info.h"
00056 #include "sched_cflow.h"
00057 
00058 #define DUMP_OP_SUMMARY(o,f)  { fprintf ((f), "[OP%3d][BB%3d][%-7s]", \
00059                                 OP_map_idx((o)), BB_id(OP_bb((o))), \
00060                                 TOP_Name(OP_code(o))); }        
00061 
00062 #define BEGIN_WITH_NEW_LINE(f) { fprintf (f,"\n") ; } 
00063 
00064 char * sched_dump_indent = "   " ; 
00065 char * caption_l_bar = "=========>" ; 
00066 char * caption_r_bar = "<=========" ;
00067 
00068     /* each line of dumpped content do not exceed this very much
00069      */
00070 enum { LINE_MAX_WIDTH = 75, };
00071 
00072 /* ===============================================================
00073  *
00074  *      Dump a individual CANDIDATE 
00075  * 
00076  * ==============================================================
00077  */
00078 void
00079 CANDIDATE :: Dump (FILE *f, BOOL verbose,
00080                       FAVOR_DELAY_HEUR * heur) {
00081 
00082     if (!Op()) {
00083         fprintf (f,"CANDIDATE(%p)'s corresponding OP is NULL", this);
00084         return ;
00085     }
00086 
00087     if (verbose) {
00088         DUMP_OP_SUMMARY(Op(),f) ; 
00089     }
00090 
00091     /* We should print out the cached _e_time field, the up-to-date
00092      * e-time is print by 'Dump_OP_Heur_Info()'
00093      */
00094     fprintf (f, " %-9s %s ", 
00095                  spec_text[_spec_type],
00096                  Is_P_Ready () ? "PREADY" : "MREADY");
00097 
00098     /* print the heuristic stuff associated with this candidate
00099      */
00100     if (heur) {
00101        heur->Dump_OP_Heur_Info (_op,f,FALSE);
00102     }
00103 }
00104 
00105     /* ==============================================================
00106      *
00107      * tagRGN_INFO :: Dump 
00108      * 
00109      * Dump the status of RGN_INFO 
00110      * 
00111      * =============================================================
00112      */
00113 void
00114 RGN_INFO :: Dump (FILE * f) {
00115 
00116     if (!rgn) {
00117         fprintf (f,"REGION:(NULL)\n");
00118         return ;
00119     }
00120 
00121     char * s = NULL ;
00122 
00123     switch (skip_reason) {
00124     case SKIP_RGN_NONE:
00125         s = "(Need Scheduling)" ;
00126         break ;
00127 
00128     case SKIP_RGN_IMPROPER:
00129         s = "(Improper Region)" ;
00130         break ;
00131 
00132     case SKIP_RGN_NON_SEME:
00133         s = "(Non-SEME Region)" ;
00134         break ;
00135 
00136     case SKIP_RGN_CRITICAL_EDGE:
00137         s = "(Critical Edge present)";
00138         break ;
00139 
00140     case SKIP_RGN_DEBUG:
00141         s = "(Skip scheduling for debugging purpose)";
00142         break ;
00143 
00144     case SKIP_RGN_NO_FURTHER_OPT:
00145         s = "(Need no further opt)";
00146         break ;
00147     
00148     default:
00149         FmtAssert (FALSE,
00150             ("Unknown SKIP_SCHED_RGN_REASON (%d)", skip_reason));
00151     }
00152 
00153     fprintf (f, " %s, %s\n", s, 
00154                  in_abnormal_loop ? "In abnormal loop" : "");
00155     
00156     if (summary) { 
00157         summary->Dump (); 
00158     } else { 
00159         fprintf (f," summary : NULL") ; 
00160     }
00161 
00162     fprintf (f, "\n");
00163 }
00164 
00165 
00166 /* ==========================================================
00167  *
00168  *      Dump a whole candidate list
00169  *
00170  * =========================================================
00171  */
00172 void
00173 CAND_LIST :: Dump (FILE * f, BOOL verbose, FAVOR_DELAY_HEUR * heur) {
00174 
00175     if (verbose) {
00176         fprintf (f, "%sCANDIDATE LIST %d IN TOTAL "
00177                     "(%d TRIED)%s\n", 
00178              caption_l_bar,
00179              _total, _tried_cand_num,
00180              caption_r_bar) ;
00181     } else {
00182         BEGIN_WITH_NEW_LINE (f);
00183     }
00184 
00185     for (CAND_LIST_ITER iter(this) ; !iter.done(); iter.step ()) {
00186 
00187         CANDIDATE* cand = iter.cur ();
00188 
00189             /* we should distinguish each candidate, if its dumpped
00190              * text is terse, it may be illegible.
00191              */
00192         cand->Dump (f, TRUE, heur);
00193         fprintf (f,Cand_Has_Been_Tried (cand) ? "  TRIED":" NONTRY");
00194 
00195         BEGIN_WITH_NEW_LINE (f);
00196     }
00197 }
00198 
00199 #ifdef Is_True_On
00200 
00201 void
00202 CAND_LIST :: gdb_dump (FAVOR_DELAY_HEUR * heur) {
00203     Dump (stderr, TRUE, heur);    
00204 }
00205 
00206 #endif
00207 
00208 
00209 void
00210 SRC_BB_MGR::Dump (FILE *f) {
00211 
00212     if (!_targ) return ;
00213         
00214     fprintf (f, "SOURCE BBs OF BB:%d\n", BB_id(_targ));
00215 
00216     for (SRC_BB_INFO_ITER iter = _src_info_vect.begin () ; 
00217         iter != _src_info_vect.end() ; iter++) {
00218 
00219         SRC_BB_INFO* info = *iter ;
00220         fprintf (f, "\t====> SRC BB:%3d cutting set:", 
00221                  BB_id(info->Source_BB ()));
00222         
00223         BB_VECTOR* bbv = info->Get_Cutting_Set ();
00224         for (BB_VECTOR_ITER cs_iter = bbv->begin() ; 
00225              cs_iter != bbv->end() ; cs_iter ++) {
00226             fprintf (f,"BB:%3d ", BB_id(*cs_iter));
00227         }
00228 
00229         bbv = info->Move_Across_Or_Around_BBs ();
00230         fprintf (f, "\n\t    BBs between src BB and cutting-set:");
00231         for (BB_VECTOR_ITER tmp_iter = bbv->begin() ;
00232              tmp_iter != bbv->end() ; 
00233              tmp_iter++) {
00234 
00235             fprintf (f,"BB:%3d ", BB_id(*tmp_iter));
00236 
00237         }
00238 
00239         fprintf (f, "\n\t    Nested REGIONs between src BB and cutting-set:");
00240         REGION_VECTOR* rv = info->Move_Across_Or_Around_Nested_Rgns ();
00241         for (REGION_VECTOR_ITER rgn_iter = rv->begin ();
00242              rgn_iter != rv->end ();
00243              rgn_iter ++) {
00244 
00245             fprintf (f, "RGN:%3d ", (*rgn_iter)->Id());
00246 
00247         }
00248 
00249         fprintf (f,"\n");
00250     }
00251 
00252 }
00253 
00254 #ifdef Is_True_On
00255 
00256 void
00257 SRC_BB_MGR :: gdb_dump (void) {
00258     Dump (stderr);
00259 }
00260 
00261 #endif 
00262 
00263     /* =======================================================
00264      *
00265      *   Dump SCHED_BB_ANNOT structure's content 
00266      *
00267      * =======================================================
00268      */
00269 void
00270 SCHED_BB_ANNOT::Dump (FILE *f) {
00271 
00272     fprintf (f,"\n===========BB:%d===========\n", BB_id(_bb));
00273 
00274     if (!_1st_append_op)
00275         fprintf (f, "no appended op,") ; 
00276     else 
00277         fprintf (f, "1st appended op[%d],", OP_map_idx(_1st_append_op));
00278 
00279 
00280     if (!_last_prepend_op) 
00281         fprintf (f, "no prepend op,") ;
00282     else
00283         fprintf (f, "last prepend op[%d],", OP_map_idx(_last_prepend_op));
00284 
00285     fprintf (f, "\n");
00286 
00287     OP * op ;
00288     SCHED_OP_ANNOT * op_annot ; 
00289 
00290     FOR_ALL_BB_OPs (_bb, op) {
00291         op_annot = Get_OP_Annot(op) ;
00292         if (!op_annot) fprintf (f, "[OP:%d] NULL\n", OP_map_idx(op));
00293         else op_annot->Dump(f);
00294     }
00295 
00296 }
00297 
00298      /* =======================================================
00299       *
00300       *   Dump SCHED_RGN_ANNOT structure's status 
00301       * 
00302       * =======================================================
00303       */
00304 void
00305 SCHED_RGN_ANNOT::Dump (FILE *f) {
00306     fprintf (f, "RGN %d\n", _rgn->Id()); 
00307 }
00308 
00309     /* =====================================================
00310      *
00311      *   Dump SCHED_OP_ANNOT structure's status
00312      *
00313      * =====================================================
00314      */
00315 void
00316 SCHED_OP_ANNOT::Dump(FILE* f) {
00317     
00318     fprintf (f, 
00319         "OP[%d] %s, original home BB BB:%d, current home BB BB:%d, ext-flag:%#X\n", 
00320                  OP_map_idx(_op), TOP_Name(OP_code(_op)),
00321                  BB_id (_org_home_bb), BB_id(OP_bb(_op)),
00322                  _ext_flags);
00323 }
00324 
00325     /* ====================================================
00326      *
00327      *  Dump the content of CFG_NODE_MAP
00328      *
00329      * ===================================================
00330      */
00331 void
00332 CFG_NODE_MAP :: Dump (FILE *f) {
00333 
00334     char buf[LINE_MAX_WIDTH * 2], *next;
00335     
00336     if (_bb_map_vect.size()) {
00337         
00338         next = &buf[0]; *next = '\0';
00339         BOOL first_elem = TRUE;
00340 
00341         for (_PAIR_VECT_ITER iter = _bb_map_vect.begin () ;
00342              iter != _bb_map_vect.end ();
00343              iter ++) {
00344 
00345             next += sprintf (next, "%s<BB:%d,%p>", 
00346                                     first_elem ? "" : ", ",
00347                                     (*iter).node_id, 
00348                                     (*iter).value);
00349 
00350             if (next - &buf[0] >= LINE_MAX_WIDTH) {
00351                 fprintf (f,"%s\n", buf);
00352                 next = &buf[0];
00353             }
00354             
00355             first_elem = FALSE;
00356         }
00357         fprintf (f,"%s\n", buf);
00358     }
00359 
00360     if (_rgn_map_vect.size()) {
00361 
00362         next = &buf[0]; *next = '\0';
00363         BOOL first_elem = TRUE;
00364 
00365         for (_PAIR_VECT_ITER iter = _rgn_map_vect.begin () ;
00366              iter != _bb_map_vect.end ();
00367              iter ++) {
00368 
00369             next += sprintf (next, "%s<RGN:%d,%p>", 
00370                                     first_elem ? "" : ",",
00371                                     (*iter).node_id, 
00372                                     (*iter).value);
00373 
00374             if (next - &buf[0] >= LINE_MAX_WIDTH) {
00375                 fprintf (f, "%s\n", buf);
00376                 next = &buf[0];
00377             }
00378 
00379             first_elem = FALSE;
00380         }
00381 
00382         fprintf (f, "%s\n", buf);
00383     }
00384 }
00385 
00386 #ifdef Is_True_On
00387 
00388 void
00389 CFG_NODE_MAP :: gdb_dump (void) {
00390     Dump (stderr) ; fflush (stderr); 
00391 }
00392 
00393 #endif
00394 
00395     /* ========================================================
00396      * 
00397      *   Dump a paticular OP_HEUR_INFO structure
00398      * 
00399      * =======================================================
00400      */
00401 void
00402 FAVOR_DELAY_HEUR::tagOP_HEUR_INFO::Dump (FILE *f,BOOL verbose) {
00403 
00404     if (verbose) {
00405         DUMP_OP_SUMMARY(_op,f);
00406     }
00407 
00408     fprintf (f," FOUT %2d E_TIM %3d ISSUE_PORT_# %2d DELAY %f",
00409                 _fan_out, _e_time, 
00410                 _issuable_port_num,_delay);
00411 }
00412 
00413    /* ========================================================
00414     *
00415     *    Dump heuristic information associated with 
00416     *    the given OP
00417     *
00418     * ========================================================
00419     */
00420 void
00421 FAVOR_DELAY_HEUR :: Dump_OP_Heur_Info 
00422     (OP * op, FILE *f, BOOL verbose) {
00423    
00424     OP_HEUR_INFO * info = Get_OP_Heur_Info (op);
00425     if (info) {
00426         info->Dump (f, verbose);
00427     } else {
00428         if (verbose) DUMP_OP_SUMMARY(op,f);
00429         fprintf (f, " (NULL)");
00430     }
00431 }
00432 
00433     /* =======================================================
00434      *
00435      *   Dump heuristic information associated with OPs 
00436      *   reside in <bb>
00437      * 
00438      * =======================================================
00439      */
00440 void
00441 FAVOR_DELAY_HEUR :: Dump_OP_Heur_Info 
00442     (BB * bb, FILE *f,BOOL verbose) {
00443 
00444     if (verbose) {
00445         fprintf (f,"%sHeuritics Infor OPs Reside in BB:%d%s\n", 
00446              caption_l_bar,
00447              BB_id(bb),
00448              caption_r_bar);
00449     }
00450 
00451     OP * op ;
00452     FOR_ALL_BB_OPs(bb, op) {
00453 
00454         /* It is make no sense to dump nop's heuristic (actually
00455          * there is no heuristic stuff bound to nop.
00456          */
00457         if (OP_noop(op)) continue ;
00458 
00459         Dump_OP_Heur_Info (op,f,TRUE);
00460         BEGIN_WITH_NEW_LINE (f);
00461     }
00462 }
00463 
00464 
00465  /* ===============================================================
00466   *
00467   *    Dump the status of class FAVOR_DELAY_HEUR
00468   *
00469   * ==============================================================
00470   */
00471 void
00472 FAVOR_DELAY_HEUR::Dump (FILE * f,BOOL verbose) {
00473 
00474     if (verbose) {
00475         fprintf (f,"%s FAVOR_DELAY_HEUR status %s\n",
00476                     caption_l_bar, caption_r_bar);
00477     }
00478 
00479     if (_bb_scope) {
00480 
00481        Dump_OP_Heur_Info (_bb_scope, f, verbose);
00482 
00483     } else {
00484 
00485         for (TOPOLOGICAL_REGIONAL_CFG_ITER 
00486              iter (_rgn_scope -> Regional_Cfg()) ; iter != 0 ; ++ iter) {
00487             
00488             if ((*iter)->Is_Region ()) continue ;
00489             BB * bb = (*iter)->BB_Node ();
00490             if (BB_entry(bb) || BB_exit(bb)) { continue ; } ;
00491 
00492             Dump_OP_Heur_Info (bb, f,verbose);
00493 
00494         } /* end of for-loop */
00495     }
00496 }
00497 
00498 #ifdef Is_True_On
00499 
00500 void
00501 FAVOR_DELAY_HEUR::gdb_dump (void) {
00502     Dump (stderr, TRUE);
00503 }
00504 
00505 #endif  /* Is_True_On */
00506 
00507     /* ==========================================================
00508      *
00509      *     Trace candidate selection process 
00510      *
00511      * =========================================================
00512      */
00513 void
00514 FAVOR_DELAY_HEUR::Enable_Trace_Cand_Sel_Process (FILE* f=stderr) {
00515 
00516     _trace_cand_sel = TRUE;
00517     _trace_file = f ;
00518     
00519 }
00520 
00521 void
00522 FAVOR_DELAY_HEUR :: Disable_Trace_Cand_Sel_Process (void) {
00523     
00524     _trace_cand_sel = FALSE;
00525 
00526     if (_trace_file) {
00527         fclose(_trace_file); _trace_file = NULL ;
00528     }
00529 }
00530 
00531 
00532 void 
00533 FAVOR_DELAY_HEUR :: Trace_Cand_Sel_Process (const char * fmt, ...) {
00534 
00535     Is_True (_trace_cand_sel, 
00536             ("We have not enable tracing candidate selection process yet!"));
00537 
00538     va_list ap ;
00539 
00540     va_start(ap, fmt);
00541     vfprintf (_trace_file, fmt, ap);
00542     va_end(ap);
00543 }
00544 
00545 
00546 
00547 
00548 
00549  /* =====================================================
00550   * =====================================================
00551   * 
00552   *  Dumping routines used directly by SCHEDULER
00553   *
00554   * =====================================================
00555   * =====================================================
00556   */
00557 
00558 
00559  /* =====================================================
00560   *
00561   *   Dump verbose information for a given OP 
00562   * 
00563   * =====================================================
00564   */
00565 void
00566 SCHEDULER::Dump_OP_Verbose_Info (OP* op, FILE * f) {
00567 
00568         /* 1. print the <op> itself 
00569          */
00570     DUMP_OP_SUMMARY(op,f);
00571     BEGIN_WITH_NEW_LINE(f);
00572 
00573     Set_Trace_File_internal (f);
00574     Print_OP_No_SrcLine (op);
00575     Set_Trace_File_internal (TFile);
00576 
00577     if (OP_Scheduled (op)) {
00578        fprintf (f,"ISSUE CYCLE: %3d ", OP_scycle(op));  
00579     }
00580 
00581         /*2. dump heuristic info */
00582     _heur_mgr.Dump_OP_Heur_Info (op, f,FALSE);
00583     
00584         /*3. dump its associated CADIDATE structure if any
00585          */
00586     CANDIDATE* cand = _cand_mgr.Get_Candidate (op) ;
00587     if (cand) { cand->Dump (f,FALSE); }
00588 
00589         /* ??? this should be put into cg_dep_graph.cxx */
00590 
00591     static char *arc_txt[] = {
00592         "REGIN", "REGOUT", "REGANTI", "MEMIN", "MEMOUT", "MEMANTI", 
00593         "MEMVOL", "MEMREAD", "SPILLIN", "PREFIN", "PREFOUT", "PREBR", 
00594         "POSTBR", "SCC", "PRECHK", "POSTCHK", "CTLSPEC", "MISC"
00595     };
00596 
00597         /*4. dump predecessors */
00598     fprintf (f, "\nPREDECESSORS:\n");
00599 
00600     for (ARC_LIST* arcs = OP_preds(op); 
00601          arcs != NULL; arcs = ARC_LIST_rest(arcs)) {
00602 
00603         ARC *arc = ARC_LIST_first(arcs) ;
00604         OP * pred = ARC_pred(arc) ;
00605 
00606         DUMP_OP_SUMMARY(pred,f);
00607         fprintf (f, "%-8s LAT %2d %s %-5s ", 
00608                 arc_txt[ARC_kind(arc)], 
00609                     ARC_latency(arc),
00610               ARC_is_dotted(arc)   ? "Dotted" : "Strict", 
00611               ARC_is_definite(arc) ? "Def" : "Indef");
00612         
00613         _heur_mgr.Dump_OP_Heur_Info (pred,f,FALSE); 
00614         if (OP_Scheduled(pred)) { fprintf (f," SCH") ; }
00615         BEGIN_WITH_NEW_LINE(f);
00616     }
00617 
00618         /*5. dump succs 
00619          */
00620     fprintf (f,"\nSuccessors:\n") ; 
00621     for (ARC_LIST* arcs = OP_succs(op); 
00622          arcs != NULL; arcs = ARC_LIST_rest(arcs)) {
00623         
00624         ARC * arc = ARC_LIST_first(arcs) ;
00625         OP  * succ = ARC_succ(arc);
00626 
00627         DUMP_OP_SUMMARY(succ,f);
00628         fprintf (f, "%-9s LATENCY %3d %-8s %s ", 
00629                 arc_txt[ARC_kind(arc)], 
00630                     ARC_latency(arc),
00631               ARC_is_dotted(arc)   ? "Dotted" : "Strict", 
00632               ARC_is_definite(arc) ? "Def" : "Indef");
00633 
00634         _heur_mgr.Dump_OP_Heur_Info (succ,f,FALSE); 
00635         if (OP_Scheduled(succ)) { fprintf (f," SCH") ; }
00636 
00637         BEGIN_WITH_NEW_LINE(f);
00638     }
00639 }
00640 
00641 
00642 /* ====================================================================
00643  *
00644  * SCHEDULER::Dump_IR (void)
00645  * 
00646  * We does not encourage dumping IR in this way. use SCHED_Dump_IR 
00647  * instead. 
00648  * 
00649  * ===================================================================
00650  */
00651 void
00652 SCHEDULER :: Dump_IR (FILE *f) {
00653 
00654     FmtAssert (FALSE,
00655         ("Please Use 'SCHED_Dump_IR' to dump IR instead!"));
00656 }
00657 
00658 /* ===================================================================
00659  *
00660  *  SCHEDULER::Dump_DAG ()
00661  * 
00662  * dump the dependence DAG into file <f>   
00663  * 
00664  * ==================================================================
00665  */
00666 void
00667 SCHEDULER :: Dump_DAG (FILE *f) {
00668 
00669     if (_global) {
00670 
00671         for (TOPOLOGICAL_REGIONAL_CFG_ITER cfg_iter(_region->Regional_Cfg()); 
00672              cfg_iter != 0; 
00673              ++cfg_iter) {
00674 
00675             if ((*cfg_iter)->Is_Region ())  continue ;
00676 
00677             BB * b = (*cfg_iter)->BB_Node ();
00678             if (BB_entry(b) || BB_exit(b))  continue ;
00679 
00680             CG_DEP_Trace_Graph(b);
00681         } /* end of for(TOPOLOGICAL...) */
00682 
00683     } else { 
00684 
00685         CG_DEP_Trace_Graph(_target_bb);
00686 
00687     }
00688 }
00689 
00690 
00691 /* ====================================================================
00692  *
00693  *  SCHEDULER::Dump ()
00694  * 
00695  *  Dump IR, candidate list, DAG etc.
00696  *
00697  * ===================================================================
00698  */
00699 void
00700 SCHEDULER::Dump (FILE *f) {
00701     
00702     FmtAssert (FALSE,
00703         ("SCHEDULER::Dump () has yet implemented!"));
00704 }
00705 
00706 
00707     /* ===============================================================
00708      *
00709      *   SCHED_Dump_IR 
00710      *
00711      *  dump IR of OPs in current code motion scope 
00712      * 
00713      *  prepass:    before or after register allocation
00714      *  bef_sched:  indicate whether IR is dumpped before 
00715      *              code motion occurs or after it 
00716      *  gcm:        global or local code motion 
00717      *  f:          it is self-descriptive
00718      *
00719      * ===============================================================
00720      */
00721 void
00722 SCHED_Dump_IR (BOOL prepass, BOOL bef_sched, BOOL gcm,FILE *f=stderr) {
00723 
00724     FILE * ftmp = TFile ;
00725     Set_Trace_File_internal (f);
00726 
00727     /* print header */
00728     fprintf (f, "\n%s\n IR %s ORC %s %s CODE MOTION (BEGIN)\n\n%s\n",
00729                 DBar,  
00730                 bef_sched ? "before"  : "after", 
00731                 prepass   ? "PREPASS" : "POSTPASS", 
00732                 gcm       ? "GLOBAL"  : "LOCAL",
00733                 DBar);
00734 
00735  
00736     for (BB* bb = REGION_First_BB; bb; bb = BB_next(bb)) {
00737         Print_BB_No_Srclines (bb);
00738 
00739         /* extra empty line to ease the navigation in vi */
00740         fprintf (f, "\n");
00741     }
00742  
00743     fprintf (f, "\n%s\n IR %s ORC %s %s CODE MOTION (END)\n\n%s\n",
00744                 DBar,  
00745                 bef_sched ? "before"  : "after", 
00746                 prepass   ? "PREPASS" : "POSTPASS", 
00747                 gcm       ? "GLOBAL"  : "LOCAL",
00748                 DBar);
00749 
00750     Set_Trace_File_internal (ftmp); 
00751 }
00752 
00753 
00754     /* ==========================================================
00755      * ==========================================================
00756      *
00757      *      Tracing routines of sched_rgn_info.cxx package 
00758      *
00759      * ==========================================================
00760      * ==========================================================
00761      */
00762 
00763 void
00764 RGN_SUMMARY::Dump (FILE * f, BOOL verbose) {
00765 
00766     if (verbose) {
00767         fprintf (f, "REGION %d", _rgn->Id());
00768     }
00769     
00770     if (!_summary_is_valid) {
00771         fprintf (f, "Invalid summary of REGION:%d\n", 
00772                     _rgn->Id());
00773         return ;
00774     }
00775 
00776     fprintf (f,"killed defs:\n");
00777     TN_SET_Print (_killed_def,f);
00778 }
00779 
00780 void
00781 REGION_INFO_MGR :: Dump (FILE *f,BOOL verbose) {
00782 
00783     for (INNERMOST_REGION_FIRST_ITER iter(_rgn_tree);
00784          iter != 0 ; ++iter) {
00785     
00786         fprintf (f,SBar);
00787         RGN_INFO * rgn_info = Get_Rgn_Info (*iter) ;
00788         rgn_info->Dump (f) ;
00789         fprintf (f, "%s\n", SBar);
00790     }
00791 }
00792 
00793 #ifdef Is_True_On 
00794 void
00795 RGN_SUMMARY::gdb_dump (void) {
00796     Dump (stderr, TRUE);
00797 }
00798 #endif
00799 
00800 
00801     /* =======================================================
00802      * =======================================================
00803      *
00804      * 
00805      *      Traceing routines of EXEC_PATH, EXEC_PATH_SET,
00806      *      and EXEC_PATH_MGR.
00807      *
00808      * ======================================================
00809      * ======================================================
00810      */
00811 
00812     /* dump the content of EXEC_PATH 
00813      */
00814 void
00815 EXEC_PATH :: Dump (FILE *f) {
00816     
00817         /* format e.g :
00818          *  path:5 {
00819          *       3,4,r5,7, 9
00820          *  }
00821          */
00822     fprintf (f, "path:%d{\n", Id ());
00823    
00824     char buf[LINE_MAX_WIDTH * 2];
00825     char *p = buf; *p = '\0';
00826 
00827     BOOL first_elem = TRUE;
00828 
00829     for (PATH_NODE_INFO_VECT_ITER iter = _path_node_seq.begin () ;
00830          iter != _path_node_seq.end ();
00831          iter ++) {
00832 
00833         PATH_NODE_INFO ni = *iter;
00834         
00835         if (!first_elem) { *p++ = ','; } else { first_elem = FALSE; }
00836 
00837         if (ni.Node()->Is_Region ()) {
00838             p += sprintf (p, "r%d(%f)", 
00839                           ni.Node()->Region_Node()->Id(),
00840                           ni.Prob_From_Root ());
00841         } else {
00842             p += sprintf (p, "%d(%f)", 
00843                           BB_id(ni.Node()->BB_Node()),
00844                           ni.Prob_From_Root ());
00845         }
00846 
00847         if (p - &buf[0] >= LINE_MAX_WIDTH) {
00848             fprintf (f,"%s",buf); p = &buf[0]; *p = '\0';
00849             fprintf (f, "\n");
00850         }
00851     }
00852 
00853     fprintf (f, "%s\n}\n", buf);
00854 }
00855 
00856     /* =======================================================
00857      *
00858      * EXEC_PATH_SET::Dump
00859      * 
00860      * Dump the content of EXEC_PATH_SET. 
00861      * <dump_path_id_range> is the supporting routine to Dump.
00862      *
00863      * =======================================================
00864      */
00865 static void
00866 dump_path_id_range 
00867     (FILE *f, EXEC_PATH_ID begin, EXEC_PATH_ID end, BOOL* first_range) {
00868    
00869     if (!*first_range) { fprintf (f,","); }
00870     if (end == begin) { fprintf (f, "%d", begin); }
00871     else if (end > begin) {
00872         fprintf (f, "%d-%d", begin, end);
00873     } else if (end < begin) {
00874         FmtAssert (FALSE, 
00875             ("<begin>(%d) is expected no greater than <end>(%d)",
00876              begin, end));
00877     }
00878     
00879     * first_range = FALSE ;
00880 }
00881 
00882 void
00883 EXEC_PATH_SET :: Dump (FILE *f) {
00884    
00885     BOOL first_range = TRUE;
00886     fprintf (f,"{ ");
00887     
00888     EXEC_PATH_ID  range_begin = First_Path_Id ();
00889 
00890     if (EXEC_PATH_ID_IS_INVALID(range_begin)) {
00891         fprintf (f,"}\n");
00892         return ;
00893     }
00894 
00895     EXEC_PATH_ID pid,last_pid=range_begin;
00896 
00897     while (!EXEC_PATH_ID_IS_INVALID(pid = Next_Path_Id (last_pid))) {
00898 
00899         if (pid != last_pid + 1) {
00900             /* continguity stop here 
00901              */
00902             dump_path_id_range (f, range_begin, last_pid,&first_range);
00903             range_begin = pid;
00904         }
00905         last_pid = pid;
00906     }
00907 
00908     dump_path_id_range (f, range_begin, last_pid, &first_range);
00909 
00910     fprintf (f,"}\n");
00911 }
00912 
00913     /* dump the content of EXEC_PATH_MGR 
00914      */
00915 void
00916 EXEC_PATH_MGR :: Dump (FILE *f) {
00917     
00918     if (!_region) {  return ; };
00919 
00920     fprintf (f, "EXEC PATH INFO OF REGION:%d\n", _region->Id());
00921     
00922     for (EXEC_PATH_VECT_ITER iter = _pathv.begin () ;
00923          iter != _pathv.end ();
00924          iter ++) {
00925         (*iter)->Dump (f); 
00926     }
00927 
00928     fprintf (f,"%s", DBar);
00929 }
00930 
00931 #ifdef Is_True_On 
00932 
00933 void
00934 EXEC_PATH :: gdb_dump (void) {
00935     Dump (stderr); fflush (stderr);
00936 }
00937 
00938 void
00939 EXEC_PATH_SET :: gdb_dump (void) {
00940     Dump (stderr); fflush (stderr);
00941 }
00942 
00943 void
00944 EXEC_PATH_MGR :: gdb_dump (void) {
00945     Dump (stderr); fflush (stderr);
00946 }
00947 
00948 #endif /* Is_True_On */
osprey/be/cg/orc_intel/sched_dump.cxx
