ghc/runtime/main/Ticky.lc

   1 %
   2 % (c) The GRASP Project, Glasgow University, 1992-1993
   3 %
   4 %************************************************************************
   5 %*                                                                      *
   6 \section[Ticky.lc]{Stuff for ``ticky-ticky'' profiling}
   7 %*                                                                      *
   8 %************************************************************************
   9
  10 Goes with \tr{imports/Ticky.lh}; more documentation there.
  11
  12 %************************************************************************
  13 %*                                                                      *
  14 \subsection[Ticky-counters]{Declare all the counters}
  15 %*                                                                      *
  16 %************************************************************************
  17
  18 \begin{code}
  19 #define NULL_REG_MAP    /* Not threaded */
  20
  21 #include "../storage/SMinternal.h" /* Bad boy, Will (ToDo) */
  22
  23 #if defined(TICKY_TICKY)
  24
  25 I_ ALLOC_HEAP_ctr = 0;
  26 I_ ALLOC_HEAP_tot = 0;
  27
  28 PP_ max_SpA; /* set in re_enterable_part_of_main */
  29 P_  max_SpB;
  30
  31 /* not used at all
  32 I_ A_STK_REUSE_ctr = 0;
  33 I_ B_STK_REUSE_ctr = 0;
  34 */
  35 I_ A_STK_STUB_ctr = 0;
  36
  37 I_ ALLOC_FUN_ctr = 0;
  38 I_ ALLOC_FUN_adm = 0;
  39 I_ ALLOC_FUN_gds = 0;
  40 I_ ALLOC_FUN_slp = 0;
  41 I_ ALLOC_FUN_hst[5] = {0,0,0,0,0};
  42 I_ ALLOC_THK_ctr = 0;
  43 I_ ALLOC_THK_adm = 0;
  44 I_ ALLOC_THK_gds = 0;
  45 I_ ALLOC_THK_slp = 0;
  46 I_ ALLOC_THK_hst[5] = {0,0,0,0,0};
  47 I_ ALLOC_CON_ctr = 0;
  48 I_ ALLOC_CON_adm = 0;
  49 I_ ALLOC_CON_gds = 0;
  50 I_ ALLOC_CON_slp = 0;
  51 I_ ALLOC_CON_hst[5] = {0,0,0,0,0};
  52 I_ ALLOC_TUP_ctr = 0;
  53 I_ ALLOC_TUP_adm = 0;
  54 I_ ALLOC_TUP_gds = 0;
  55 I_ ALLOC_TUP_slp = 0;
  56 I_ ALLOC_TUP_hst[5] = {0,0,0,0,0};
  57 I_ ALLOC_BH_ctr = 0;
  58 I_ ALLOC_BH_adm = 0;
  59 I_ ALLOC_BH_gds = 0;
  60 I_ ALLOC_BH_slp = 0;
  61 I_ ALLOC_BH_hst[5] = {0,0,0,0,0};
  62 I_ ALLOC_PRIM_ctr = 0;
  63 I_ ALLOC_PRIM_adm = 0;
  64 I_ ALLOC_PRIM_gds = 0;
  65 I_ ALLOC_PRIM_slp = 0;
  66 I_ ALLOC_PRIM_hst[5] = {0,0,0,0,0};
  67 I_ ALLOC_UPD_PAP_ctr = 0;
  68 I_ ALLOC_UPD_PAP_adm = 0;
  69 I_ ALLOC_UPD_PAP_gds = 0;
  70 I_ ALLOC_UPD_PAP_slp = 0;
  71 I_ ALLOC_UPD_PAP_hst[5] = {0,0,0,0,0};
  72
  73 #ifdef CONCURRENT
  74 I_ ALLOC_STK_ctr = 0;
  75 I_ ALLOC_STK_adm = 0;
  76 I_ ALLOC_STK_gds = 0;
  77 I_ ALLOC_STK_slp = 0;
  78 I_ ALLOC_STK_hst[5] = {0,0,0,0,0};
  79 I_ ALLOC_TSO_ctr = 0;
  80 I_ ALLOC_TSO_adm = 0;
  81 I_ ALLOC_TSO_gds = 0;
  82 I_ ALLOC_TSO_slp = 0;
  83 I_ ALLOC_TSO_hst[5] = {0,0,0,0,0};
  84
  85 # ifdef PAR
  86 I_ ALLOC_FMBQ_ctr = 0;
  87 I_ ALLOC_FMBQ_adm = 0;
  88 I_ ALLOC_FMBQ_gds = 0;
  89 I_ ALLOC_FMBQ_slp = 0;
  90 I_ ALLOC_FMBQ_hst[5] = {0,0,0,0,0};
  91 I_ ALLOC_FME_ctr = 0;
  92 I_ ALLOC_FME_adm = 0;
  93 I_ ALLOC_FME_gds = 0;
  94 I_ ALLOC_FME_slp = 0;
  95 I_ ALLOC_FME_hst[5] = {0,0,0,0,0};
  96 I_ ALLOC_BF_ctr = 0;
  97 I_ ALLOC_BF_adm = 0;
  98 I_ ALLOC_BF_gds = 0;
  99 I_ ALLOC_BF_slp = 0;
 100 I_ ALLOC_BF_hst[5] = {0,0,0,0,0};
 101 # endif
 102 #endif
 103
 104 I_ ENT_VIA_NODE_ctr = 0;
 105 I_ ENT_CON_ctr = 0;
 106 I_ ENT_FUN_STD_ctr = 0;
 107 I_ ENT_FUN_DIRECT_ctr = 0;
 108 I_ ENT_IND_ctr = 0;
 109 I_ ENT_PAP_ctr = 0;
 110 I_ ENT_THK_ctr = 0;
 111
 112 I_ RET_NEW_IN_HEAP_ctr = 0;
 113 I_ RET_NEW_IN_REGS_ctr = 0;
 114 I_ RET_OLD_IN_HEAP_ctr = 0;
 115 I_ RET_OLD_IN_REGS_ctr = 0;
 116 I_ RET_SEMI_BY_DEFAULT_ctr = 0;
 117 I_ RET_SEMI_IN_HEAP_ctr = 0;
 118 I_ RET_SEMI_IN_REGS_ctr = 0;
 119 I_ RET_SEMI_FAILED_IND_ctr = 0;
 120 I_ RET_SEMI_FAILED_UNEVAL_ctr = 0;
 121 I_ VEC_RETURN_ctr = 0;
 122
 123 I_ RET_NEW_IN_HEAP_hst[9] = {0,0,0,0,0,0,0,0,0};
 124 I_ RET_NEW_IN_REGS_hst[9] = {0,0,0,0,0,0,0,0,0};
 125 I_ RET_OLD_IN_HEAP_hst[9] = {0,0,0,0,0,0,0,0,0};
 126 I_ RET_OLD_IN_REGS_hst[9] = {0,0,0,0,0,0,0,0,0};
 127 /* no such thing: I_ RET_SEMI_BY_DEFAULT_hst[9] = {0,0,0,0,0,0,0,0,0}; */
 128 I_ RET_SEMI_IN_HEAP_hst[9] = {0,0,0,0,0,0,0,0,0};
 129 I_ RET_SEMI_IN_REGS_hst[9] = {0,0,0,0,0,0,0,0,0};
 130 I_ RET_VEC_RETURN_hst[9] = {0,0,0,0,0,0,0,0,0};
 131
 132 I_ RET_SEMI_loads_avoided = 0;
 133
 134 I_ ReturnInRegsNodeValid = 0; /* i.e., False */
 135
 136 I_ UPDF_OMITTED_ctr = 0;
 137 I_ UPDF_STD_PUSHED_ctr = 0;
 138 I_ UPDF_CON_PUSHED_ctr = 0;
 139 I_ UPDF_HOLE_PUSHED_ctr = 0;
 140
 141 I_ UPDF_RCC_PUSHED_ctr = 0;
 142 I_ UPDF_RCC_OMITTED_ctr = 0;
 143
 144 I_ UPD_EXISTING_ctr = 0;
 145 I_ UPD_SQUEEZED_ctr = 0;
 146 I_ UPD_CON_W_NODE_ctr = 0;
 147 I_ UPD_CON_IN_PLACE_ctr = 0;
 148 I_ UPD_CON_IN_NEW_ctr = 0;
 149 I_ UPD_PAP_IN_PLACE_ctr = 0;
 150 I_ UPD_PAP_IN_NEW_ctr = 0;
 151
 152 I_ UPD_CON_IN_PLACE_hst[9] = {0,0,0,0,0,0,0,0,0};
 153 I_ UPD_CON_IN_NEW_hst[9] = {0,0,0,0,0,0,0,0,0};
 154 I_ UPD_PAP_IN_NEW_hst[9] = {0,0,0,0,0,0,0,0,0};
 155
 156 I_ UPD_ENTERED_hst[9] = {0,0,0,0,0,0,0,0,0};
 157
 158 I_ UPD_NEW_IND_ctr = 0;
 159 I_ UPD_NEW_IN_PLACE_PTRS_ctr = 0;
 160 I_ UPD_NEW_IN_PLACE_NOPTRS_ctr = 0;
 161 I_ UPD_OLD_IND_ctr = 0;
 162 I_ UPD_OLD_IN_PLACE_PTRS_ctr = 0;
 163 I_ UPD_OLD_IN_PLACE_NOPTRS_ctr = 0;
 164
 165 I_ UPD_IN_PLACE_COPY_ctr = 0;
 166
 167 I_ GC_SEL_ABANDONED_ctr = 0;
 168 I_ GC_SEL_MINOR_ctr = 0;
 169 I_ GC_SEL_MAJOR_ctr = 0;
 170
 171 I_ GC_SHORT_IND_ctr = 0;
 172 I_ GC_SHORT_CAF_ctr = 0;
 173 I_ GC_COMMON_CHARLIKE_ctr = 0;
 174 I_ GC_COMMON_INTLIKE_ctr = 0;
 175 I_ GC_COMMON_INTLIKE_FAIL_ctr = 0;
 176 I_ GC_COMMON_CONST_ctr = 0;
 177 \end{code}
 178
 179 %************************************************************************
 180 %*                                                                      *
 181 \subsection[Ticky-print]{Print out all the counters}
 182 %*                                                                      *
 183 %************************************************************************
 184
 185 \begin{code}
 186 static void printRegisteredCounterInfo (FILE *); /* fwd decl */
 187
 188 #define INTAVG(a,b) ((b == 0) ? 0.0 : ((StgDouble) (a) / (StgDouble) (b)))
 189 #define PC(a)       (100.0 * a)
 190
 191 #define AVG(thing) \
 192         StgDouble CAT2(avg,thing)  = INTAVG(CAT2(tot,thing),CAT2(ctr,thing))
 193
 194 void
 195 PrintTickyInfo()
 196 {
 197   I_ i;
 198   I_ tot_allocs = /* total number of things allocated */
 199         ALLOC_FUN_ctr + ALLOC_THK_ctr + ALLOC_CON_ctr + ALLOC_TUP_ctr +
 200 #ifdef CONCURRENT
 201         ALLOC_STK_ctr + ALLOC_TSO_ctr +
 202 # ifdef PAR
 203         ALLOC_FMBQ_ctr + ALLOC_FME_ctr + ALLOC_BF_ctr +
 204 # endif
 205 #endif
 206         ALLOC_BH_ctr  + ALLOC_UPD_PAP_ctr + ALLOC_PRIM_ctr;
 207   I_ tot_adm_wds = /* total number of admin words allocated */
 208         ALLOC_FUN_adm + ALLOC_THK_adm + ALLOC_CON_adm + ALLOC_TUP_adm +
 209 #ifdef CONCURRENT
 210         ALLOC_STK_adm + ALLOC_TSO_adm +
 211 # ifdef PAR
 212         ALLOC_FMBQ_adm + ALLOC_FME_adm + ALLOC_BF_adm +
 213 # endif
 214 #endif
 215         ALLOC_BH_adm  + ALLOC_UPD_PAP_adm + ALLOC_PRIM_adm;
 216   I_ tot_gds_wds = /* total number of words of ``good stuff'' allocated */
 217         ALLOC_FUN_gds + ALLOC_THK_gds + ALLOC_CON_gds + ALLOC_TUP_gds +
 218 #ifdef CONCURRENT
 219         ALLOC_STK_gds + ALLOC_TSO_gds +
 220 # ifdef PAR
 221         ALLOC_FMBQ_gds + ALLOC_FME_gds + ALLOC_BF_gds +
 222 # endif
 223 #endif
 224         ALLOC_BH_gds  + ALLOC_UPD_PAP_gds + ALLOC_PRIM_gds;
 225   I_ tot_slp_wds = /* total number of ``slop'' words allocated */
 226         ALLOC_FUN_slp + ALLOC_THK_slp + ALLOC_CON_slp + ALLOC_TUP_slp +
 227 #ifdef CONCURRENT
 228         ALLOC_STK_slp + ALLOC_TSO_slp +
 229 # ifdef PAR
 230         ALLOC_FMBQ_slp + ALLOC_FME_slp + ALLOC_BF_slp +
 231 # endif
 232 #endif
 233         ALLOC_BH_slp  + ALLOC_UPD_PAP_slp + ALLOC_PRIM_slp;
 234   I_ tot_wds = /* total words */
 235         tot_adm_wds + tot_gds_wds + tot_slp_wds;
 236
 237   I_ tot_enters =
 238         ENT_CON_ctr + ENT_FUN_DIRECT_ctr +
 239         ENT_IND_ctr + ENT_PAP_ctr + ENT_THK_ctr;
 240   I_ jump_direct_enters =
 241         tot_enters - ENT_VIA_NODE_ctr;
 242   I_ bypass_enters =
 243         ENT_FUN_DIRECT_ctr -
 244         (ENT_FUN_STD_ctr - UPD_PAP_IN_PLACE_ctr - UPD_PAP_IN_NEW_ctr);
 245
 246   I_ tot_returns_in_regs =
 247         RET_NEW_IN_REGS_ctr + RET_OLD_IN_REGS_ctr + RET_SEMI_IN_REGS_ctr;
 248   I_ tot_returns_in_heap =
 249         RET_NEW_IN_HEAP_ctr + RET_OLD_IN_HEAP_ctr + RET_SEMI_IN_HEAP_ctr + RET_SEMI_BY_DEFAULT_ctr/*???*/;
 250   I_ tot_returns_of_new =
 251         RET_NEW_IN_REGS_ctr + RET_NEW_IN_HEAP_ctr;
 252   I_ tot_returns_of_old = /* NB: NOT USED ???!  94/05 WDP */
 253         RET_OLD_IN_REGS_ctr + RET_OLD_IN_HEAP_ctr +
 254         RET_SEMI_BY_DEFAULT_ctr + RET_SEMI_IN_HEAP_ctr + RET_SEMI_IN_REGS_ctr /*???*/;
 255
 256   I_ tot_returns =
 257         tot_returns_in_regs + tot_returns_in_heap;
 258
 259   I_ tot_upd_frames =
 260         UPDF_STD_PUSHED_ctr + UPDF_CON_PUSHED_ctr;      /*DBH*/
 261
 262   I_ con_updates =
 263         UPD_CON_W_NODE_ctr + UPD_CON_IN_PLACE_ctr + UPD_CON_IN_NEW_ctr;
 264   I_ pap_updates =
 265         UPD_PAP_IN_PLACE_ctr + UPD_PAP_IN_NEW_ctr;
 266   I_ tot_updates =
 267         UPD_EXISTING_ctr + UPD_SQUEEZED_ctr + con_updates + pap_updates;
 268   I_ tot_in_place_updates =
 269         UPD_CON_IN_PLACE_ctr + UPD_PAP_IN_PLACE_ctr;
 270
 271   I_ tot_new_updates =
 272         UPD_NEW_IN_PLACE_NOPTRS_ctr + UPD_NEW_IN_PLACE_PTRS_ctr + UPD_NEW_IND_ctr;
 273   I_ tot_old_updates =
 274         UPD_OLD_IN_PLACE_NOPTRS_ctr + UPD_OLD_IN_PLACE_PTRS_ctr + UPD_OLD_IND_ctr;
 275   I_ tot_gengc_updates =
 276         tot_new_updates + tot_old_updates;
 277
 278   FILE *tf = RTSflags.TickyFlags.tickyFile;
 279
 280   fprintf(tf,"\n\nALLOCATIONS: %ld (%ld words total: %ld admin, %ld goods, %ld slop)\n",
 281         tot_allocs, tot_wds, tot_adm_wds, tot_gds_wds, tot_slp_wds);
 282   fprintf(tf,"\t\t\t\ttotal words:\t    2     3     4     5    6+\n");
 283
 284 #define ALLOC_HISTO_MAGIC(categ) \
 285         (PC(INTAVG(CAT3(ALLOC_,categ,_hst)[0], CAT3(ALLOC_,categ,_ctr)))), \
 286         (PC(INTAVG(CAT3(ALLOC_,categ,_hst)[1], CAT3(ALLOC_,categ,_ctr)))), \
 287         (PC(INTAVG(CAT3(ALLOC_,categ,_hst)[2], CAT3(ALLOC_,categ,_ctr)))), \
 288         (PC(INTAVG(CAT3(ALLOC_,categ,_hst)[3], CAT3(ALLOC_,categ,_ctr)))), \
 289         (PC(INTAVG(CAT3(ALLOC_,categ,_hst)[4], CAT3(ALLOC_,categ,_ctr))))
 290
 291   fprintf(tf,"%7ld (%5.1f%%) function values",
 292         ALLOC_FUN_ctr,
 293         PC(INTAVG(ALLOC_FUN_ctr, tot_allocs)));
 294   if (ALLOC_FUN_ctr != 0)
 295       fprintf(tf,"\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(FUN));
 296
 297   fprintf(tf,"\n%7ld (%5.1f%%) thunks",
 298         ALLOC_THK_ctr,
 299         PC(INTAVG(ALLOC_THK_ctr, tot_allocs)));
 300   if (ALLOC_THK_ctr != 0)
 301       fprintf(tf,"\t\t\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(THK));
 302
 303   fprintf(tf,"\n%7ld (%5.1f%%) data values",
 304         ALLOC_CON_ctr,
 305         PC(INTAVG(ALLOC_CON_ctr, tot_allocs)));
 306   if (ALLOC_CON_ctr != 0)
 307       fprintf(tf,"\t\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(CON));
 308
 309   fprintf(tf,"\n%7ld (%5.1f%%) big tuples",
 310         ALLOC_TUP_ctr,
 311         PC(INTAVG(ALLOC_TUP_ctr, tot_allocs)));
 312   if (ALLOC_TUP_ctr != 0)
 313       fprintf(tf,"\t\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(TUP));
 314
 315   fprintf(tf,"\n%7ld (%5.1f%%) black holes",
 316         ALLOC_BH_ctr,
 317         PC(INTAVG(ALLOC_BH_ctr, tot_allocs)));
 318   if (ALLOC_BH_ctr != 0)
 319       fprintf(tf,"\t\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(BH));
 320
 321   fprintf(tf,"\n%7ld (%5.1f%%) prim things",
 322         ALLOC_PRIM_ctr,
 323         PC(INTAVG(ALLOC_PRIM_ctr, tot_allocs)));
 324   if (ALLOC_PRIM_ctr != 0)
 325       fprintf(tf,"\t\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(PRIM));
 326
 327   fprintf(tf,"\n%7ld (%5.1f%%) partial applications",
 328         ALLOC_UPD_PAP_ctr,
 329         PC(INTAVG(ALLOC_UPD_PAP_ctr, tot_allocs)));
 330   if (ALLOC_UPD_PAP_ctr != 0)
 331       fprintf(tf,"\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(UPD_PAP));
 332
 333 #ifdef CONCURRENT
 334   fprintf(tf,"\n%7ld (%5.1f%%) stack objects",
 335         ALLOC_STK_ctr,
 336         PC(INTAVG(ALLOC_STK_ctr, tot_allocs)));
 337   if (ALLOC_STK_ctr != 0)
 338       fprintf(tf,"\t\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(STK));
 339   fprintf(tf,"\n%7ld (%5.1f%%) thread state objects",
 340         ALLOC_TSO_ctr,
 341         PC(INTAVG(ALLOC_TSO_ctr, tot_allocs)));
 342   if (ALLOC_TSO_ctr != 0)
 343       fprintf(tf,"\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(TSO));
 344 # ifdef PAR
 345   fprintf(tf,"\n%7ld (%5.1f%%) thread state objects",
 346         ALLOC_FMBQ_ctr,
 347         PC(INTAVG(ALLOC_FMBQ_ctr, tot_allocs)));
 348   if (ALLOC_FMBQ_ctr != 0)
 349       fprintf(tf,"\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(FMBQ));
 350   fprintf(tf,"\n%7ld (%5.1f%%) thread state objects",
 351         ALLOC_FME_ctr,
 352         PC(INTAVG(ALLOC_FME_ctr, tot_allocs)));
 353   if (ALLOC_FME_ctr != 0)
 354       fprintf(tf,"\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(FME));
 355   fprintf(tf,"\n%7ld (%5.1f%%) thread state objects",
 356         ALLOC_BF_ctr,
 357         PC(INTAVG(ALLOC_BF_ctr, tot_allocs)));
 358   if (ALLOC_BF_ctr != 0)
 359       fprintf(tf,"\t\t%5.1f %5.1f %5.1f %5.1f %5.1f", ALLOC_HISTO_MAGIC(BF));
 360 # endif
 361 #endif
 362   fprintf(tf,"\n");
 363
 364   fprintf(tf,"\nTotal storage-manager allocations: %ld (%ld words)\n\t[%ld words lost to speculative heap-checks]\n", ALLOC_HEAP_ctr, ALLOC_HEAP_tot, ALLOC_HEAP_tot - tot_wds);
 365
 366   fprintf(tf,"\nSTACK USAGE:\n"); /* NB: some bits are direction sensitive */
 367   fprintf(tf,"\tA stack slots stubbed: %ld\n", A_STK_STUB_ctr);
 368 /* not used at all
 369   fprintf(tf,"\tA stack slots re-used: %ld\n", A_STK_REUSE_ctr);
 370   fprintf(tf,"\tB stack slots re-used: %ld\n", B_STK_REUSE_ctr);
 371 */
 372 #ifndef CONCURRENT
 373   fprintf(tf,"\tA stack max. depth: %ld words\n",
 374                 (I_) (stackInfo.botA - max_SpA));
 375   fprintf(tf,"\tB stack max. depth: %ld words\n",
 376                 (I_) (max_SpB - stackInfo.botB));       /* And cheating, too (ToDo) */
 377 #endif
 378
 379   fprintf(tf,"\nENTERS: %ld  of which %ld (%.1f%%) direct to the entry code\n\t\t  [the rest indirected via Node's info ptr]\n",
 380         tot_enters,
 381         jump_direct_enters,
 382         PC(INTAVG(jump_direct_enters,tot_enters)));
 383   fprintf(tf,"%7ld (%5.1f%%) thunks\n",
 384         ENT_THK_ctr,
 385         PC(INTAVG(ENT_THK_ctr,tot_enters)));
 386   fprintf(tf,"%7ld (%5.1f%%) data values\n",
 387         ENT_CON_ctr,
 388         PC(INTAVG(ENT_CON_ctr,tot_enters)));
 389   fprintf(tf,"%7ld (%5.1f%%) function values\n\t\t  [of which %ld (%.1f%%) bypassed arg-satisfaction chk]\n",
 390         ENT_FUN_DIRECT_ctr,
 391         PC(INTAVG(ENT_FUN_DIRECT_ctr,tot_enters)),
 392         bypass_enters,
 393         PC(INTAVG(bypass_enters,ENT_FUN_DIRECT_ctr)));
 394   fprintf(tf,"%7ld (%5.1f%%) partial applications\n",
 395         ENT_PAP_ctr,
 396         PC(INTAVG(ENT_PAP_ctr,tot_enters)));
 397   fprintf(tf,"%7ld (%5.1f%%) indirections\n",
 398         ENT_IND_ctr,
 399         PC(INTAVG(ENT_IND_ctr,tot_enters)));
 400
 401   fprintf(tf,"\nRETURNS: %ld\n", tot_returns);
 402   fprintf(tf,"%7ld (%5.1f%%) in registers [the rest in the heap]\n",
 403         tot_returns_in_regs,
 404         PC(INTAVG(tot_returns_in_regs,tot_returns)));
 405   fprintf(tf,"%7ld (%5.1f%%) from entering a new constructor\n\t\t  [the rest from entering an existing constructor]\n",
 406         tot_returns_of_new,
 407         PC(INTAVG(tot_returns_of_new,tot_returns)));
 408   fprintf(tf,"%7ld (%5.1f%%) vectored [the rest unvectored]\n",
 409         VEC_RETURN_ctr,
 410         PC(INTAVG(VEC_RETURN_ctr,tot_returns)));
 411
 412 /*
 413   fprintf(tf, "RET_xxx: %7ld: ", RET_xxx_ctr);
 414   for (i = 0; i < 9; i++) { fprintf(tf, "%5.1f%%",
 415                                 PC(INTAVG(RET_xxx_hst[i],RET_xxx_ctr))); }
 416   fprintf(tf, "\n");
 417 */
 418   fprintf(tf, "\nRET_OLD_IN_REGS: %7ld: ", RET_OLD_IN_REGS_ctr);
 419   for (i = 0; i < 9; i++) { fprintf(tf, "%5.1f%%",
 420                                 PC(INTAVG(RET_OLD_IN_REGS_hst[i],RET_OLD_IN_REGS_ctr))); }
 421   fprintf(tf, "\n");
 422   fprintf(tf, "RET_NEW_IN_REGS: %7ld: ", RET_NEW_IN_REGS_ctr);
 423   for (i = 0; i < 9; i++) { fprintf(tf, "%5.1f%%",
 424                             PC(INTAVG(RET_NEW_IN_REGS_hst[i],RET_NEW_IN_REGS_ctr))); }
 425   fprintf(tf, "\n");
 426   fprintf(tf, "RET_OLD_IN_HEAP: %7ld: ", RET_OLD_IN_HEAP_ctr);
 427   for (i = 0; i < 9; i++) { fprintf(tf, "%5.1f%%",
 428                                 PC(INTAVG(RET_OLD_IN_HEAP_hst[i],RET_OLD_IN_HEAP_ctr))); }
 429   fprintf(tf, "\n");
 430   fprintf(tf, "RET_NEW_IN_HEAP: %7ld: ", RET_NEW_IN_HEAP_ctr);
 431   for (i = 0; i < 9; i++) { fprintf(tf, "%5.1f%%",
 432                                 PC(INTAVG(RET_NEW_IN_HEAP_hst[i],RET_NEW_IN_HEAP_ctr))); }
 433   fprintf(tf, "\n");
 434   fprintf(tf, "\nRET_VEC_RETURN : %7ld: ", VEC_RETURN_ctr);
 435   for (i = 0; i < 9; i++) { fprintf(tf, "%5.1f%%",
 436                                 PC(INTAVG(RET_VEC_RETURN_hst[i],VEC_RETURN_ctr))); }
 437   fprintf(tf, "\n");
 438
 439   fprintf(tf,"\nUPDATE FRAMES: %ld (%ld omitted from thunks)\n",
 440         tot_upd_frames,
 441         UPDF_OMITTED_ctr);
 442   fprintf(tf,"%7ld (%5.1f%%) standard frames\n",
 443         UPDF_STD_PUSHED_ctr,
 444         PC(INTAVG(UPDF_STD_PUSHED_ctr,tot_upd_frames)));
 445   fprintf(tf,"%7ld (%5.1f%%) constructor frames\n",
 446         UPDF_CON_PUSHED_ctr,
 447         PC(INTAVG(UPDF_CON_PUSHED_ctr,tot_upd_frames)));
 448   fprintf(tf,"\t\t  [of which %ld (%.1f%%) were for black-holes]\n",
 449         UPDF_HOLE_PUSHED_ctr,
 450         PC(INTAVG(UPDF_HOLE_PUSHED_ctr,UPDF_CON_PUSHED_ctr)));  /*DBH*/
 451
 452   if (UPDF_RCC_PUSHED_ctr != 0)
 453      fprintf(tf,"%7ld restore cost centre frames (%ld omitted)\n",
 454         UPDF_RCC_PUSHED_ctr,
 455         UPDF_RCC_OMITTED_ctr);
 456
 457   fprintf(tf,"\nUPDATES: %ld\n", tot_updates);
 458   fprintf(tf,"%7ld (%5.1f%%) data values\n\t\t  [%ld in place, %ld allocated new space, %ld with Node]\n",
 459         con_updates,
 460         PC(INTAVG(con_updates,tot_updates)),
 461         UPD_CON_IN_PLACE_ctr, UPD_CON_IN_NEW_ctr, UPD_CON_W_NODE_ctr);
 462   fprintf(tf,"%7ld (%5.1f%%) partial applications\n\t\t  [%ld in place, %ld allocated new space]\n",
 463         pap_updates,
 464         PC(INTAVG(pap_updates,tot_updates)),
 465         UPD_PAP_IN_PLACE_ctr, UPD_PAP_IN_NEW_ctr);
 466   fprintf(tf,"%7ld (%5.1f%%) updates to existing heap objects (%ld by squeezing)\n",
 467         UPD_EXISTING_ctr + UPD_SQUEEZED_ctr,
 468         PC(INTAVG(UPD_EXISTING_ctr + UPD_SQUEEZED_ctr, tot_updates)),
 469         UPD_SQUEEZED_ctr);
 470   fprintf(tf,"%7ld (%5.1f%%) in-place updates copied\n",
 471         UPD_IN_PLACE_COPY_ctr,
 472         PC(INTAVG(UPD_IN_PLACE_COPY_ctr,tot_in_place_updates)));
 473 #if 0
 474   if (UPD_ENTERED_ctr != 0) {
 475       fprintf(tf,"%7ld (%5.1f%%) subsequently entered\n",
 476               UPD_ENTERED_ctr,
 477               PC(INTAVG(UPD_ENTERED_ctr,tot_updates)));
 478       fprintf(tf,"%7ld (%5.1f%%) subsequently entered more than once\n",
 479               UPD_ENTERED_AGAIN_ctr,
 480               PC(INTAVG(UPD_ENTERED_AGAIN_ctr,tot_updates)));
 481   }
 482 #endif
 483 /*
 484   fprintf(tf, "UPD_xxx: %7ld: ", UPD_xxx_ctr);
 485   for (i = 0; i < 9; i++) { fprintf(tf, "%7ld", UPD_xxx_hst[i]); }
 486   fprintf(tf, "\n");
 487 */
 488   fprintf(tf, "UPD_CON_IN_PLACE: %7ld: ", UPD_CON_IN_PLACE_ctr);
 489   for (i = 0; i < 9; i++) { fprintf(tf, "%7ld", UPD_CON_IN_PLACE_hst[i]); }
 490   fprintf(tf, "\n");
 491   fprintf(tf, "UPD_CON_IN_NEW:   %7ld: ", UPD_CON_IN_NEW_ctr);
 492   for (i = 0; i < 9; i++) { fprintf(tf, "%7ld", UPD_CON_IN_NEW_hst[i]); }
 493   fprintf(tf, "\n");
 494   fprintf(tf, "UPD_PAP_IN_NEW:   %7ld: ", UPD_PAP_IN_NEW_ctr);
 495   for (i = 0; i < 9; i++) { fprintf(tf, "%7ld", UPD_PAP_IN_NEW_hst[i]); }
 496   fprintf(tf, "\n");
 497
 498   if (tot_gengc_updates != 0) {
 499       fprintf(tf,"\nNEW GEN UPDATES: %ld (%5.1f%%)\n",
 500               tot_new_updates,
 501               PC(INTAVG(tot_new_updates,tot_gengc_updates)));
 502       fprintf(tf,"%7ld (%5.1f%%) indirections\n",
 503               UPD_NEW_IND_ctr,
 504               PC(INTAVG(UPD_NEW_IND_ctr,tot_gengc_updates)));
 505       fprintf(tf,"%7ld (%5.1f%%) inplace with ptrs\n",
 506               UPD_NEW_IN_PLACE_PTRS_ctr,
 507               PC(INTAVG(UPD_NEW_IN_PLACE_PTRS_ctr,tot_gengc_updates)));
 508       fprintf(tf,"%7ld (%5.1f%%) inplace without ptrs\n",
 509               UPD_NEW_IN_PLACE_NOPTRS_ctr,
 510               PC(INTAVG(UPD_NEW_IN_PLACE_NOPTRS_ctr,tot_gengc_updates)));
 511       fprintf(tf,"\nOLD GEN UPDATES: %ld (%5.1f%%)\n",
 512               tot_old_updates,
 513               PC(INTAVG(tot_old_updates,tot_gengc_updates)));
 514       fprintf(tf,"%7ld (%5.1f%%) indirections\n",
 515               UPD_OLD_IND_ctr,
 516               PC(INTAVG(UPD_OLD_IND_ctr,tot_gengc_updates)));
 517       fprintf(tf,"%7ld (%5.1f%%) inplace with ptrs\n",
 518               UPD_OLD_IN_PLACE_PTRS_ctr,
 519               PC(INTAVG(UPD_OLD_IN_PLACE_PTRS_ctr,tot_gengc_updates)));
 520       fprintf(tf,"%7ld (%5.1f%%) inplace without ptrs\n",
 521               UPD_OLD_IN_PLACE_NOPTRS_ctr,
 522               PC(INTAVG(UPD_OLD_IN_PLACE_NOPTRS_ctr,tot_gengc_updates)));
 523   }
 524
 525   printRegisteredCounterInfo(tf);
 526
 527   fprintf(tf,"\n**************************************************\n");
 528
 529   /* here, we print out all the raw numbers; these are really
 530     more useful when we want to snag them for subsequent
 531     rdb-etc processing. WDP 95/11
 532   */
 533
 534 #define PR_CTR(ctr) \
 535   do { fprintf(tf,"%7ld " #ctr "\n", ctr); } while(0)
 536 #define PR_HST(hst,i) \
 537   do { fprintf(tf,"%7ld " #hst "_" #i "\n", hst[i]); } while(0)
 538
 539   PR_CTR(ALLOC_HEAP_ctr);
 540   PR_CTR(ALLOC_HEAP_tot);
 541
 542 #ifndef CONCURRENT
 543   fprintf(tf,"%7ld HWM_SpA\n", (I_) (stackInfo.botA - max_SpA));
 544   fprintf(tf,"%7ld HWM_SpB\n", (I_) (max_SpB - stackInfo.botB));
 545 #endif
 546
 547   PR_CTR(A_STK_STUB_ctr);
 548
 549   PR_CTR(ALLOC_FUN_ctr);
 550   PR_CTR(ALLOC_FUN_adm);
 551   PR_CTR(ALLOC_FUN_gds);
 552   PR_CTR(ALLOC_FUN_slp);
 553   PR_HST(ALLOC_FUN_hst,0);
 554   PR_HST(ALLOC_FUN_hst,1);
 555   PR_HST(ALLOC_FUN_hst,2);
 556   PR_HST(ALLOC_FUN_hst,3);
 557   PR_HST(ALLOC_FUN_hst,4);
 558   PR_CTR(ALLOC_THK_ctr);
 559   PR_CTR(ALLOC_THK_adm);
 560   PR_CTR(ALLOC_THK_gds);
 561   PR_CTR(ALLOC_THK_slp);
 562   PR_HST(ALLOC_THK_hst,0);
 563   PR_HST(ALLOC_THK_hst,1);
 564   PR_HST(ALLOC_THK_hst,2);
 565   PR_HST(ALLOC_THK_hst,3);
 566   PR_HST(ALLOC_THK_hst,4);
 567   PR_CTR(ALLOC_CON_ctr);
 568   PR_CTR(ALLOC_CON_adm);
 569   PR_CTR(ALLOC_CON_gds);
 570   PR_CTR(ALLOC_CON_slp);
 571   PR_HST(ALLOC_CON_hst,0);
 572   PR_HST(ALLOC_CON_hst,1);
 573   PR_HST(ALLOC_CON_hst,2);
 574   PR_HST(ALLOC_CON_hst,3);
 575   PR_HST(ALLOC_CON_hst,4);
 576   PR_CTR(ALLOC_TUP_ctr);
 577   PR_CTR(ALLOC_TUP_adm);
 578   PR_CTR(ALLOC_TUP_gds);
 579   PR_CTR(ALLOC_TUP_slp);
 580   PR_HST(ALLOC_TUP_hst,0);
 581   PR_HST(ALLOC_TUP_hst,1);
 582   PR_HST(ALLOC_TUP_hst,2);
 583   PR_HST(ALLOC_TUP_hst,3);
 584   PR_HST(ALLOC_TUP_hst,4);
 585   PR_CTR(ALLOC_BH_ctr);
 586   PR_CTR(ALLOC_BH_adm);
 587   PR_CTR(ALLOC_BH_gds);
 588   PR_CTR(ALLOC_BH_slp);
 589   PR_HST(ALLOC_BH_hst,0);
 590   PR_HST(ALLOC_BH_hst,1);
 591   PR_HST(ALLOC_BH_hst,2);
 592   PR_HST(ALLOC_BH_hst,3);
 593   PR_HST(ALLOC_BH_hst,4);
 594   PR_CTR(ALLOC_PRIM_ctr);
 595   PR_CTR(ALLOC_PRIM_adm);
 596   PR_CTR(ALLOC_PRIM_gds);
 597   PR_CTR(ALLOC_PRIM_slp);
 598   PR_HST(ALLOC_PRIM_hst,0);
 599   PR_HST(ALLOC_PRIM_hst,1);
 600   PR_HST(ALLOC_PRIM_hst,2);
 601   PR_HST(ALLOC_PRIM_hst,3);
 602   PR_HST(ALLOC_PRIM_hst,4);
 603   PR_CTR(ALLOC_UPD_PAP_ctr);
 604   PR_CTR(ALLOC_UPD_PAP_adm);
 605   PR_CTR(ALLOC_UPD_PAP_gds);
 606   PR_CTR(ALLOC_UPD_PAP_slp);
 607   PR_HST(ALLOC_UPD_PAP_hst,0);
 608   PR_HST(ALLOC_UPD_PAP_hst,1);
 609   PR_HST(ALLOC_UPD_PAP_hst,2);
 610   PR_HST(ALLOC_UPD_PAP_hst,3);
 611   PR_HST(ALLOC_UPD_PAP_hst,4);
 612
 613 #ifdef CONCURRENT
 614   PR_CTR(ALLOC_STK_ctr);
 615   PR_CTR(ALLOC_STK_adm);
 616   PR_CTR(ALLOC_STK_gds);
 617   PR_CTR(ALLOC_STK_slp);
 618   PR_HST(ALLOC_STK_hst,0);
 619   PR_HST(ALLOC_STK_hst,1);
 620   PR_HST(ALLOC_STK_hst,2);
 621   PR_HST(ALLOC_STK_hst,3);
 622   PR_HST(ALLOC_STK_hst,4);
 623   PR_CTR(ALLOC_TSO_ctr);
 624   PR_CTR(ALLOC_TSO_adm);
 625   PR_CTR(ALLOC_TSO_gds);
 626   PR_CTR(ALLOC_TSO_slp);
 627   PR_HST(ALLOC_TSO_hst,0);
 628   PR_HST(ALLOC_TSO_hst,1);
 629   PR_HST(ALLOC_TSO_hst,2);
 630   PR_HST(ALLOC_TSO_hst,3);
 631   PR_HST(ALLOC_TSO_hst,4);
 632
 633 # ifdef PAR
 634   PR_CTR(ALLOC_FMBQ_ctr);
 635   PR_CTR(ALLOC_FMBQ_adm);
 636   PR_CTR(ALLOC_FMBQ_gds);
 637   PR_CTR(ALLOC_FMBQ_slp);
 638   PR_HST(ALLOC_FMBQ_hst,0);
 639   PR_HST(ALLOC_FMBQ_hst,1);
 640   PR_HST(ALLOC_FMBQ_hst,2);
 641   PR_HST(ALLOC_FMBQ_hst,3);
 642   PR_HST(ALLOC_FMBQ_hst,4);
 643   PR_CTR(ALLOC_FME_ctr);
 644   PR_CTR(ALLOC_FME_adm);
 645   PR_CTR(ALLOC_FME_gds);
 646   PR_CTR(ALLOC_FME_slp);
 647   PR_HST(ALLOC_FME_hst,0);
 648   PR_HST(ALLOC_FME_hst,1);
 649   PR_HST(ALLOC_FME_hst,2);
 650   PR_HST(ALLOC_FME_hst,3);
 651   PR_HST(ALLOC_FME_hst,4);
 652   PR_CTR(ALLOC_BF_ctr);
 653   PR_CTR(ALLOC_BF_adm);
 654   PR_CTR(ALLOC_BF_gds);
 655   PR_CTR(ALLOC_BF_slp);
 656   PR_HST(ALLOC_BF_hst,0);
 657   PR_HST(ALLOC_BF_hst,1);
 658   PR_HST(ALLOC_BF_hst,2);
 659   PR_HST(ALLOC_BF_hst,3);
 660   PR_HST(ALLOC_BF_hst,4);
 661 # endif
 662 #endif
 663
 664   PR_CTR(ENT_VIA_NODE_ctr);
 665   PR_CTR(ENT_CON_ctr);
 666   PR_CTR(ENT_FUN_STD_ctr);
 667   PR_CTR(ENT_FUN_DIRECT_ctr);
 668   PR_CTR(ENT_IND_ctr);
 669   PR_CTR(ENT_PAP_ctr);
 670   PR_CTR(ENT_THK_ctr);
 671
 672   PR_CTR(RET_NEW_IN_HEAP_ctr);
 673   PR_CTR(RET_NEW_IN_REGS_ctr);
 674   PR_CTR(RET_OLD_IN_HEAP_ctr);
 675   PR_CTR(RET_OLD_IN_REGS_ctr);
 676   PR_CTR(RET_SEMI_BY_DEFAULT_ctr);
 677   PR_CTR(RET_SEMI_IN_HEAP_ctr);
 678   PR_CTR(RET_SEMI_IN_REGS_ctr);
 679   PR_CTR(RET_SEMI_FAILED_IND_ctr);
 680   PR_CTR(RET_SEMI_FAILED_UNEVAL_ctr);
 681   PR_CTR(VEC_RETURN_ctr);
 682
 683   PR_HST(RET_NEW_IN_HEAP_hst,0);
 684   PR_HST(RET_NEW_IN_HEAP_hst,1);
 685   PR_HST(RET_NEW_IN_HEAP_hst,2);
 686   PR_HST(RET_NEW_IN_HEAP_hst,3);
 687   PR_HST(RET_NEW_IN_HEAP_hst,4);
 688   PR_HST(RET_NEW_IN_HEAP_hst,5);
 689   PR_HST(RET_NEW_IN_HEAP_hst,6);
 690   PR_HST(RET_NEW_IN_HEAP_hst,7);
 691   PR_HST(RET_NEW_IN_HEAP_hst,8);
 692   PR_HST(RET_NEW_IN_REGS_hst,0);
 693   PR_HST(RET_NEW_IN_REGS_hst,1);
 694   PR_HST(RET_NEW_IN_REGS_hst,2);
 695   PR_HST(RET_NEW_IN_REGS_hst,3);
 696   PR_HST(RET_NEW_IN_REGS_hst,4);
 697   PR_HST(RET_NEW_IN_REGS_hst,5);
 698   PR_HST(RET_NEW_IN_REGS_hst,6);
 699   PR_HST(RET_NEW_IN_REGS_hst,7);
 700   PR_HST(RET_NEW_IN_REGS_hst,8);
 701   PR_HST(RET_OLD_IN_HEAP_hst,0);
 702   PR_HST(RET_OLD_IN_HEAP_hst,1);
 703   PR_HST(RET_OLD_IN_HEAP_hst,2);
 704   PR_HST(RET_OLD_IN_HEAP_hst,3);
 705   PR_HST(RET_OLD_IN_HEAP_hst,4);
 706   PR_HST(RET_OLD_IN_HEAP_hst,5);
 707   PR_HST(RET_OLD_IN_HEAP_hst,6);
 708   PR_HST(RET_OLD_IN_HEAP_hst,7);
 709   PR_HST(RET_OLD_IN_HEAP_hst,8);
 710   PR_HST(RET_OLD_IN_REGS_hst,0);
 711   PR_HST(RET_OLD_IN_REGS_hst,1);
 712   PR_HST(RET_OLD_IN_REGS_hst,2);
 713   PR_HST(RET_OLD_IN_REGS_hst,3);
 714   PR_HST(RET_OLD_IN_REGS_hst,4);
 715   PR_HST(RET_OLD_IN_REGS_hst,5);
 716   PR_HST(RET_OLD_IN_REGS_hst,6);
 717   PR_HST(RET_OLD_IN_REGS_hst,7);
 718   PR_HST(RET_OLD_IN_REGS_hst,8);
 719   PR_HST(RET_SEMI_IN_HEAP_hst,0);
 720   PR_HST(RET_SEMI_IN_HEAP_hst,1);
 721   PR_HST(RET_SEMI_IN_HEAP_hst,2);
 722   PR_HST(RET_SEMI_IN_HEAP_hst,3);
 723   PR_HST(RET_SEMI_IN_HEAP_hst,4);
 724   PR_HST(RET_SEMI_IN_HEAP_hst,5);
 725   PR_HST(RET_SEMI_IN_HEAP_hst,6);
 726   PR_HST(RET_SEMI_IN_HEAP_hst,7);
 727   PR_HST(RET_SEMI_IN_HEAP_hst,8);
 728   PR_HST(RET_SEMI_IN_REGS_hst,0);
 729   PR_HST(RET_SEMI_IN_REGS_hst,1);
 730   PR_HST(RET_SEMI_IN_REGS_hst,2);
 731   PR_HST(RET_SEMI_IN_REGS_hst,3);
 732   PR_HST(RET_SEMI_IN_REGS_hst,4);
 733   PR_HST(RET_SEMI_IN_REGS_hst,5);
 734   PR_HST(RET_SEMI_IN_REGS_hst,6);
 735   PR_HST(RET_SEMI_IN_REGS_hst,7);
 736   PR_HST(RET_SEMI_IN_REGS_hst,8);
 737   PR_HST(RET_VEC_RETURN_hst,0);
 738   PR_HST(RET_VEC_RETURN_hst,1);
 739   PR_HST(RET_VEC_RETURN_hst,2);
 740   PR_HST(RET_VEC_RETURN_hst,3);
 741   PR_HST(RET_VEC_RETURN_hst,4);
 742   PR_HST(RET_VEC_RETURN_hst,5);
 743   PR_HST(RET_VEC_RETURN_hst,6);
 744   PR_HST(RET_VEC_RETURN_hst,7);
 745   PR_HST(RET_VEC_RETURN_hst,8);
 746
 747   PR_CTR(RET_SEMI_loads_avoided);
 748
 749   PR_CTR(UPDF_OMITTED_ctr);
 750   PR_CTR(UPDF_STD_PUSHED_ctr);
 751   PR_CTR(UPDF_CON_PUSHED_ctr);
 752   PR_CTR(UPDF_HOLE_PUSHED_ctr);
 753
 754   PR_CTR(UPDF_RCC_PUSHED_ctr);
 755   PR_CTR(UPDF_RCC_OMITTED_ctr);
 756
 757   PR_CTR(UPD_EXISTING_ctr);
 758   PR_CTR(UPD_SQUEEZED_ctr);
 759   PR_CTR(UPD_CON_W_NODE_ctr);
 760   PR_CTR(UPD_CON_IN_PLACE_ctr);
 761   PR_CTR(UPD_CON_IN_NEW_ctr);
 762   PR_CTR(UPD_PAP_IN_PLACE_ctr);
 763   PR_CTR(UPD_PAP_IN_NEW_ctr);
 764
 765   PR_HST(UPD_CON_IN_PLACE_hst,0);
 766   PR_HST(UPD_CON_IN_PLACE_hst,1);
 767   PR_HST(UPD_CON_IN_PLACE_hst,2);
 768   PR_HST(UPD_CON_IN_PLACE_hst,3);
 769   PR_HST(UPD_CON_IN_PLACE_hst,4);
 770   PR_HST(UPD_CON_IN_PLACE_hst,5);
 771   PR_HST(UPD_CON_IN_PLACE_hst,6);
 772   PR_HST(UPD_CON_IN_PLACE_hst,7);
 773   PR_HST(UPD_CON_IN_PLACE_hst,8);
 774   PR_HST(UPD_CON_IN_NEW_hst,0);
 775   PR_HST(UPD_CON_IN_NEW_hst,1);
 776   PR_HST(UPD_CON_IN_NEW_hst,2);
 777   PR_HST(UPD_CON_IN_NEW_hst,3);
 778   PR_HST(UPD_CON_IN_NEW_hst,4);
 779   PR_HST(UPD_CON_IN_NEW_hst,5);
 780   PR_HST(UPD_CON_IN_NEW_hst,6);
 781   PR_HST(UPD_CON_IN_NEW_hst,7);
 782   PR_HST(UPD_CON_IN_NEW_hst,8);
 783   PR_HST(UPD_PAP_IN_NEW_hst,0);
 784   PR_HST(UPD_PAP_IN_NEW_hst,1);
 785   PR_HST(UPD_PAP_IN_NEW_hst,2);
 786   PR_HST(UPD_PAP_IN_NEW_hst,3);
 787   PR_HST(UPD_PAP_IN_NEW_hst,4);
 788   PR_HST(UPD_PAP_IN_NEW_hst,5);
 789   PR_HST(UPD_PAP_IN_NEW_hst,6);
 790   PR_HST(UPD_PAP_IN_NEW_hst,7);
 791   PR_HST(UPD_PAP_IN_NEW_hst,8);
 792
 793   PR_HST(UPD_ENTERED_hst,0);
 794   PR_HST(UPD_ENTERED_hst,1);
 795   PR_HST(UPD_ENTERED_hst,2);
 796   PR_HST(UPD_ENTERED_hst,3);
 797   PR_HST(UPD_ENTERED_hst,4);
 798   PR_HST(UPD_ENTERED_hst,5);
 799   PR_HST(UPD_ENTERED_hst,6);
 800   PR_HST(UPD_ENTERED_hst,7);
 801   PR_HST(UPD_ENTERED_hst,8);
 802
 803   PR_CTR(UPD_NEW_IND_ctr);
 804   PR_CTR(UPD_NEW_IN_PLACE_PTRS_ctr);
 805   PR_CTR(UPD_NEW_IN_PLACE_NOPTRS_ctr);
 806   PR_CTR(UPD_OLD_IND_ctr);
 807   PR_CTR(UPD_OLD_IN_PLACE_PTRS_ctr);
 808   PR_CTR(UPD_OLD_IN_PLACE_NOPTRS_ctr);
 809
 810   PR_CTR(UPD_IN_PLACE_COPY_ctr);
 811
 812   PR_CTR(GC_SEL_ABANDONED_ctr);
 813   PR_CTR(GC_SEL_MINOR_ctr);
 814   PR_CTR(GC_SEL_MAJOR_ctr);
 815   PR_CTR(GC_SHORT_IND_ctr);
 816   PR_CTR(GC_SHORT_CAF_ctr);
 817   PR_CTR(GC_COMMON_CHARLIKE_ctr);
 818   PR_CTR(GC_COMMON_INTLIKE_ctr);
 819   PR_CTR(GC_COMMON_INTLIKE_FAIL_ctr);
 820   PR_CTR(GC_COMMON_CONST_ctr);
 821 }
 822 \end{code}
 823
 824 %************************************************************************
 825 %*                                                                      *
 826 \subsection[Ticky-ent-counters]{Handle named entry counters}
 827 %*                                                                      *
 828 %************************************************************************
 829
 830 Data structure used in ``registering'' one of these counters.
 831 \begin{code}
 832 struct ent_counter *ListOfEntryCtrs = NULL; /* root of list of them */
 833 \end{code}
 834
 835 To print out all the registered-counter info:
 836 \begin{code}
 837 static void
 838 printRegisteredCounterInfo (FILE *tf)
 839 {
 840     struct ent_counter *p;
 841
 842     if ( ListOfEntryCtrs != NULL ) {
 843         fprintf(tf,"\n**************************************************\n");
 844     }
 845
 846     for (p = ListOfEntryCtrs; p != NULL; p = p->link) {
 847         /* common stuff first; then the wrapper info if avail */
 848         fprintf(tf, "%-40s%u\t%u\t%u\t%-16s%ld",
 849                 p->f_str,
 850                 p->arity,
 851                 p->Astk_args,
 852                 p->Bstk_args,
 853                 p->f_arg_kinds,
 854                 p->ctr);
 855
 856         if ( p->wrap_str == NULL ) {
 857             fprintf(tf, "\n");
 858
 859         } else {
 860             fprintf(tf, "\t%s\t%s\n",
 861                 p->wrap_str,
 862                 p->wrap_arg_kinds);
 863         }
 864     }
 865 }
 866 \end{code}
 867
 868 That's all, folks.
 869 \begin{code}
 870 #endif /* TICKY_TICKY */
 871 \end{code}