00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047 #include <alloca.h>
00048 #include <stdio.h>
00049 #include <list>
00050 #include <set>
00051 #include <vector>
00052 #include <iterator>
00053 #include "defs.h"
00054 #include "bb.h"
00055 #include "op.h"
00056 #include "tracing.h"
00057 #include "cg_region.h"
00058 #include "cg_dep_graph.h"
00059 #include "DaVinci.h"
00060 #include "vt_dag.h"
00061 #include "vt_region.h"
00062 #include "vt_partition.h"
00063 #include "region_bb_util.h"
00064 #include "dominate.h"
00065 #include "ir_reader.h"
00066 #include "register.h"
00067 #include "tn.h"
00068 #include "annotations.h"
00069 #include "cg_loop_scc.h"
00070
00071 class dp{
00072 public:
00073 static void bb_dag(BB *bb);
00074 static void region_cfg(REGION *r);
00075 static void draw_bb(BB *bb);
00076 static void dump_bb(BB *bbg);
00077 static void dump_op(const OP *opg);
00078 static void region_tree(REGION *r);
00079 static void partition_graph(PARTITION_GRAPH *pg);
00080 static void region_partition_graph(REGION *r);
00081 static void global_cfg();
00082 static void dump_bb_vector(BB_VECTOR& bbsg);
00083 static void dump_node_vector(NODE_VECTOR& nodesg);
00084 static void dump_node_list(std::list<REGIONAL_CFG_NODE *>& nodes);
00085 static BB * get_bb (mBB_NUM bb_idg);
00086 static OP * get_op (mBB_NUM bb_id, mUINT16 map_idxg);
00087 static void dump_succs(mBB_NUM bb_id, mUINT16 map_idxg);
00088 static void dump_succs_p(OP* op);
00089 static void dump_preds(mBB_NUM bb_id, mUINT16 map_idxg);
00090 static void dump_preds_p(OP* op);
00091 static void dump_pdom(mBB_NUM bb_idg);
00092 static void dump_tn_set (BS *setg);
00093 static void dump_bb_set(BB_SET* setg);
00094 static void dump_reg_set(REGISTER_SET regset);
00095 static void dump_tn_stl_set(std::set<TN*>& TNsg);
00096 static void dump_rotate_info(struct ROTATING_KERNEL_INFO *info, int type = 0);
00097 static void tn_num(TN* tng);
00098 static void dump_wn_stmt(WN* wn);
00099 static void dump_wn_node(WN* wn);
00100 static void dump_st_type(ST* stg);
00101 static void dump_scc(CG_LOOP_SCC *scc);
00102 };
00103
00104 void dp::dump_scc(CG_LOOP_SCC *scc)
00105 {
00106 Set_Trace_File_internal(stderr);
00107 CG_LOOP_SCC_Print(scc);
00108 Set_Trace_File_internal(TFile);
00109 }
00110
00111 void dp::dump_st_type(ST* st)
00112 {
00113 TY_IDX ty_idx = ST_type(st);
00114 TY& ty = Ty_Table[ty_idx];
00115 ty.Print(stderr);
00116 }
00117
00118 void dp::dump_wn_node(WN* wn)
00119 {
00120 dump_wn(wn);
00121 }
00122
00123 void dp::dump_wn_stmt(WN* wn)
00124 {
00125 dump_tree(wn);
00126 }
00127
00128 void dp::dump_tn_stl_set(std::set<TN*>& TNs)
00129 {
00130 for(std::set<TN*>::iterator iter = TNs.begin(); iter != TNs.end(); iter++){
00131 TN* tn = *iter;
00132 if(TN_is_global_reg(tn)){
00133 fprintf(stderr,"GTN%d", TN_number(tn));
00134 } else {
00135 fprintf(stderr,"TN%d", TN_number(tn));
00136 }
00137 }
00138 fprintf(stderr,"\n");
00139 fflush(stderr);
00140 }
00141
00142 void dp::dump_rotate_info(struct ROTATING_KERNEL_INFO *info, int type)
00143 {
00144
00145 static char *reg_class[] = { "u","r","f","p","b","a","c"};
00146 std::vector<struct tn *> copyin = ROTATING_KERNEL_INFO_copyin(info);
00147 std::vector<struct tn *> copyout = ROTATING_KERNEL_INFO_copyout(info);
00148 std::vector<struct tn *> localdef = ROTATING_KERNEL_INFO_localdef(info);
00149
00150 if(type == 0 || type == 1){
00151 fprintf(stderr,"Copyin: ");
00152 for(std::vector<struct tn *>::iterator iter = copyin.begin(); iter != copyin.end(); iter++){
00153 TN *tn = *iter;
00154 int reg = TN_register(tn) - 1;
00155 int regc = TN_register_class(tn);
00156 int number = TN_number(tn);
00157 fprintf(stderr,"[%s%d/%d] ", reg_class[regc],reg,number);
00158 }
00159 fprintf(stderr,"\n");
00160 fflush(stderr);
00161 }
00162 if(type == 0 || type == 2){
00163 fprintf(stderr,"Copyout: ");
00164 for(std::vector<struct tn *>::iterator iter = copyout.begin(); iter != copyout.end(); iter++){
00165 TN *tn = *iter;
00166 int reg = TN_register(tn) - 1;
00167 int regc = TN_register_class(tn);
00168 int number = TN_number(tn);
00169 fprintf(stderr,"[%s%d/%d] ", reg_class[regc],reg,number);
00170 }
00171 fprintf(stderr,"\n");
00172 fflush(stderr);
00173 }
00174 if(type == 0 || type == 3){
00175 fprintf(stderr,"Zombie: ");
00176 for(std::vector<struct tn *>::iterator iter = localdef.begin(); iter != localdef.end(); iter++){
00177 TN *tn = *iter;
00178 int reg = TN_register(tn) - 1;
00179 int regc = TN_register_class(tn);
00180 int number = TN_number(tn);
00181 fprintf(stderr,"[%s%d/%d] ", reg_class[regc],reg,number);
00182 }
00183 fprintf(stderr,"\n");
00184 fflush(stderr);
00185 }
00186
00187
00188
00189 }
00190
00191
00192 void dp::tn_num(TN* tn)
00193 {
00194 if(TN_is_global_reg(tn)){
00195 fprintf(stderr,"GTN%d", TN_number(tn));
00196 } else {
00197 fprintf(stderr,"TN%d", TN_number(tn));
00198 }
00199 }
00200
00201 void dp::dump_bb_vector(BB_VECTOR& bbs) {
00202 for (BB_VECTOR_ITER iter = bbs.begin();iter != bbs.end();iter++) {
00203 fprintf(stderr,"BB_%d\n",BB_id(*iter));
00204 }
00205 }
00206
00207 void dump_node_list(std::list<REGIONAL_CFG_NODE *>& nodes)
00208 {
00209 for(std::list<REGIONAL_CFG_NODE *>::iterator iter = nodes.begin(); iter != nodes.end(); iter++){
00210 REGIONAL_CFG_NODE *node = *iter;
00211
00212 if (!node->Is_Region()) {
00213 fprintf(stderr,"BB%d",BB_id(node->BB_Node()));
00214 } else {
00215 fprintf(stderr,"RGN%d",(node->Region_Node())->Id());
00216 }
00217 }
00218 fprintf(stderr,"\n");
00219 }
00220
00221 void dp::dump_node_vector(NODE_VECTOR& nodes) {
00222 for (NODE_VECTOR_ITER iter = nodes.begin();iter != nodes.end();iter++) {
00223 REGIONAL_CFG_NODE *node = *iter;
00224
00225 if (!node->Is_Region()) {
00226 fprintf(stderr,"BB Node_%d\n",BB_id(node->BB_Node()));
00227 } else {
00228 fprintf(stderr,"REGION Node_%d\n",(node->Region_Node())->Id());
00229 }
00230 }
00231 fprintf(stderr,"\n");
00232 }
00233
00234 void dp::region_tree(REGION *r) {
00235 draw_region_tree(r);
00236 }
00237
00238 void dp::partition_graph(PARTITION_GRAPH *pg) {
00239 draw_partition_graph(pg);
00240 }
00241
00242 void dp::region_partition_graph(REGION *r) {
00243 draw_partition_graph(Get_PRDB()->Partition_Graph(r));
00244 }
00245
00246 void dp::bb_dag(BB *bb) {
00247 char caption[100];
00248 sprintf (caption,"BB (id = %d) dependency graph" , bb->id);
00249 draw_bb_dependence_graph(bb,caption);
00250 }
00251
00252 void dp::draw_bb(BB *bb)
00253 {
00254 char caption[100];
00255 sprintf (caption,"BB (id = %d) op graph" , bb->id);
00256 draw_bb_op (bb,caption);
00257 }
00258
00259 void dp::dump_bb(BB *bb)
00260 {
00261 Set_Trace_File_internal(stderr);
00262 Print_BB_No_Srclines(bb);
00263 Set_Trace_File_internal(TFile);
00264 }
00265
00266
00267 void dp::dump_op(const OP *op)
00268 {
00269 fprintf (stderr, "[map_idx %d]" , OP_map_idx(op));
00270 Set_Trace_File_internal(stderr);
00271 Print_OP_No_SrcLine(op);
00272 Set_Trace_File_internal(TFile);
00273 }
00274
00275 void dp::region_cfg(REGION *r)
00276 {
00277 draw_regional_cfg(r);
00278 }
00279
00280 void dp::global_cfg()
00281 {
00282 draw_global_cfg();
00283 }
00284
00285 BB *
00286 dp::get_bb (mBB_NUM bb_id) {
00287 for (BB* bb = REGION_First_BB; bb != NULL; bb = BB_next(bb)) {
00288 if (BB_id (bb) == bb_id) {
00289 fprintf (stderr, "BB: %d Address: %p\n", bb_id,bb);
00290 return bb ;
00291 }
00292 }
00293 return NULL ;
00294 }
00295
00296 OP *
00297 dp::get_op (mBB_NUM bb_id, mUINT16 map_idx)
00298 {
00299 BB * bb = dp::get_bb (bb_id) ;
00300 if (!bb) return NULL ;
00301
00302 OP * op ;
00303 FOR_ALL_BB_OPs (bb, op) {
00304 if (OP_map_idx (op) == map_idx) {
00305 fprintf (stderr, "OP Address: %p\n", op);
00306 return op ;
00307 }
00308 }
00309 return NULL ;
00310 }
00311
00312 static char *arc_txt[] = {
00313 "REGIN",
00314 "REGOUT",
00315 "REGANTI",
00316 "MEMIN",
00317 "MEMOUT",
00318 "MEMANTI",
00319 "MEMVOL",
00320 "MEMREAD",
00321 "SPILLIN",
00322 "PREFIN",
00323 "PREFOUT",
00324 "PREBR",
00325 "POSTBR",
00326 "SCC",
00327 "PRECHK",
00328 "POSTCHK",
00329 "MISC"
00330 };
00331
00332 void
00333 dp::dump_succs(mBB_NUM bb_id, mUINT16 map_idx) {
00334 OP* op = dp::get_op(bb_id, map_idx);
00335 if (!op) return;
00336
00337 for(ARC_LIST* arcs = OP_succs(op); arcs != NULL; arcs = ARC_LIST_rest(arcs)) {
00338 ARC *arc = ARC_LIST_first(arcs) ;
00339 OP *succ = ARC_succ(arc) ;
00340 fprintf(stderr,"[%d/%d]\t-->%p(%s)\t LAT=%d ARC=%s\t %s\t %s\n",
00341 succ->bb->id,
00342 succ->map_idx,
00343 succ,
00344 TOP_Name((TOP)succ->opr),
00345 ARC_latency(arc),
00346 arc_txt[ARC_kind(arc)],
00347 ARC_is_dotted(arc) ? "dotted" : "strict",
00348 ARC_is_definite(arc) ? "definite" : "indefinite");
00349 }
00350
00351 return;
00352 }
00353
00354 void
00355 dp::dump_succs_p(OP* op)
00356 {
00357 mBB_NUM bb_id = op->bb->id;
00358 mUINT16 map_idx = op->map_idx;
00359 dump_succs(bb_id,map_idx);
00360 }
00361
00362
00363 void
00364 dp::dump_preds(mBB_NUM bb_id, mUINT16 map_idx) {
00365 OP* op = dp::get_op(bb_id, map_idx);
00366 if (!op) return;
00367
00368 for(ARC_LIST* arcs = OP_preds(op); arcs != NULL; arcs = ARC_LIST_rest(arcs)) {
00369 ARC *arc = ARC_LIST_first(arcs) ;
00370 OP *pred = ARC_pred(arc) ;
00371 fprintf(stderr,"[%d/%d]\t%p(%s)-->\t LAT=%d\tARC=%s\t %s\t %s\n",
00372 pred->bb->id,
00373 pred->map_idx,
00374 pred,
00375 TOP_Name((TOP)pred->opr),
00376 ARC_latency(arc),
00377 arc_txt[ARC_kind(arc)],
00378 ARC_is_dotted(arc) ? "dotted" : "strict",
00379 ARC_is_definite(arc) ? "definite" : "indefinite");
00380 }
00381
00382 return;
00383 }
00384
00385 void
00386 dp::dump_preds_p(OP* op)
00387 {
00388 mBB_NUM bb_id = op->bb->id;
00389 mUINT16 map_idx = op->map_idx;
00390 dump_preds(bb_id,map_idx);
00391 return;
00392 }
00393
00394
00395 void
00396 dp::dump_pdom(mBB_NUM bb_id) {
00397 BB * bb = dp::get_bb(bb_id) ;
00398 if (!bb) {
00399 fprintf (stderr, "no such bb %d\n" , bb_id);
00400 return ;
00401 }
00402
00403 fprintf (stderr,"\n-------- BB (%d)'s post dominator ---------\n",bb_id);
00404 BB_SET_Print (BB_pdom_set(bb), stderr);
00405
00406
00407 fprintf (stderr,"\n");
00408 fflush (stderr) ;
00409 }
00410
00411 void
00412 dp::dump_tn_set (BS *set) {
00413 TN_SET_Print (set, stderr) ;
00414 fprintf (stderr, "\n");
00415 fflush (stderr) ;
00416 }
00417
00418 void
00419 dp::dump_bb_set (BB_SET *set) {
00420 BB_SET_Print (set, stderr) ;
00421 fprintf (stderr, "\n");
00422 fflush (stderr) ;
00423 }
00424
00425 void
00426 dp::dump_reg_set(REGISTER_SET regset){
00427 REGISTER_SET_Print(regset,stderr);
00428 fprintf(stderr, "\n");
00429 fflush(stderr);
00430 }
00431
