ghc/includes/StgTicky.h

   1 /* ----------------------------------------------------------------------------
   2  * $Id: StgTicky.h,v 1.12 2002/04/09 11:00:11 njn Exp $
   3  *
   4  * (c) The AQUA project, Glasgow University, 1994-1997
   5  * (c) The GHC Team, 1998-1999
   6  *
   7  * Ticky-ticky profiling macros.
   8  *
   9  * -------------------------------------------------------------------------- */
  10
  11 #ifndef TICKY_H
  12 #define TICKY_H
  13
  14 #ifdef TICKY_TICKY
  15
  16 /* -----------------------------------------------------------------------------
  17    Allocations
  18    -------------------------------------------------------------------------- */
  19
  20 /* How many times we do a heap check and move Hp; comparing this with
  21  * the allocations gives an indication of how many things we get per trip
  22  * to the well:
  23  */
  24 #define TICK_ALLOC_HEAP(n, f_ct)                \
  25   {                                             \
  26     f_ct.allocs += (n);                         \
  27     ALLOC_HEAP_ctr++;                           \
  28     ALLOC_HEAP_tot += (n);                      \
  29   }
  30
  31 #define TICK_ALLOC_HEAP_NOCTR(n)                \
  32   {                                             \
  33     ALLOC_HEAP_ctr++;                           \
  34     ALLOC_HEAP_tot += (n);                      \
  35   }
  36
  37 /* We count things every time we allocate something in the dynamic heap.
  38  * For each, we count the number of words of (1) ``admin'' (header),
  39  * (2) good stuff (useful pointers and data), and (3) ``slop'' (extra
  40  * space, to leave room for an old generation indirection for example).
  41  *
  42  * The first five macros are inserted when the compiler generates code
  43  * to allocate something; the categories correspond to the @ClosureClass@
  44  * datatype (manifest functions, thunks, constructors, big tuples, and
  45  * partial applications).
  46  */
  47
  48 #define _HS  sizeofW(StgHeader)
  49
  50 #define TICK_ALLOC_FUN(g,s)                             \
  51         ALLOC_FUN_ctr++;        ALLOC_FUN_adm += _HS;   \
  52         ALLOC_FUN_gds += (g);   ALLOC_FUN_slp += (s);   \
  53         TICK_ALLOC_HISTO(FUN,_HS,g,s)
  54
  55 #define TICK_ALLOC_UP_THK(g,s)                          \
  56         ALLOC_UP_THK_ctr++;     ALLOC_THK_adm += _HS;   \
  57         ALLOC_THK_gds += (g);   ALLOC_THK_slp += (s);   \
  58         TICK_ALLOC_HISTO(THK,_HS,g,s)
  59
  60 #define TICK_ALLOC_SE_THK(g,s)                          \
  61         ALLOC_SE_THK_ctr++;     ALLOC_THK_adm += _HS;   \
  62         ALLOC_THK_gds += (g);   ALLOC_THK_slp += (s);   \
  63         TICK_ALLOC_HISTO(THK,_HS,g,s)
  64
  65 #define TICK_ALLOC_CON(g,s)                             \
  66         ALLOC_CON_ctr++;        ALLOC_CON_adm += _HS;   \
  67         ALLOC_CON_gds += (g);   ALLOC_CON_slp += (s);   \
  68         TICK_ALLOC_HISTO(CON,_HS,g,s)
  69
  70 #define TICK_ALLOC_TUP(g,s)                             \
  71         ALLOC_TUP_ctr++;        ALLOC_TUP_adm += _HS;   \
  72         ALLOC_TUP_gds += (g);   ALLOC_TUP_slp += (s);   \
  73         TICK_ALLOC_HISTO(TUP,_HS,g,s)
  74
  75 #define TICK_ALLOC_BH(g,s)                              \
  76         ALLOC_BH_ctr++;         ALLOC_BH_adm += _HS;    \
  77         ALLOC_BH_gds += (g);    ALLOC_BH_slp += (s);    \
  78         TICK_ALLOC_HISTO(BH,_HS,g,s)
  79
  80 #define TICK_ALLOC_UPD_PAP(g,s)                                 \
  81         ALLOC_UPD_PAP_ctr++;    ALLOC_UPD_PAP_adm += sizeofW(StgPAP)-1; \
  82         ALLOC_UPD_PAP_gds += (g); ALLOC_UPD_PAP_slp += (s);     \
  83         TICK_ALLOC_HISTO(UPD_PAP,sizeofW(StgPAP)-1,g,s)
  84
  85 #define TICK_ALLOC_TSO(g,s)                                             \
  86         ALLOC_TSO_ctr++;        ALLOC_TSO_adm += sizeofW(StgTSO);       \
  87         ALLOC_TSO_gds += (g);   ALLOC_TSO_slp += (s);                   \
  88         TICK_ALLOC_HISTO(TSO,sizeofW(StgTSO),g,s)
  89
  90 #ifdef PAR
  91 #define TICK_ALLOC_FMBQ(a,g,s)                          \
  92         ALLOC_FMBQ_ctr++;       ALLOC_FMBQ_adm += (a);  \
  93         ALLOC_FMBQ_gds += (g);  ALLOC_FMBQ_slp += (s);  \
  94         TICK_ALLOC_HISTO(FMBQ,a,g,s)
  95
  96 #define TICK_ALLOC_FME(a,g,s)                           \
  97         ALLOC_FME_ctr++;        ALLOC_FME_adm += (a);   \
  98         ALLOC_FME_gds += (g);   ALLOC_FME_slp += (s);   \
  99         TICK_ALLOC_HISTO(FME,a,g,s)
 100
 101 #define TICK_ALLOC_BF(a,g,s)                            \
 102         ALLOC_BF_ctr++; ALLOC_BF_adm += (a);            \
 103         ALLOC_BF_gds += (g);    ALLOC_BF_slp += (s);    \
 104         TICK_ALLOC_HISTO(BF,a,g,s)
 105 #endif
 106
 107 /* The histogrammy bit is fairly straightforward; the -2 is: one for
 108  * 0-origin C arrays; the other one because we do no one-word
 109  * allocations, so we would never inc that histogram slot; so we shift
 110  * everything over by one.
 111  */
 112 #define TICK_ALLOC_HISTO(categ,a,g,s)                           \
 113         { I_ __idx;                                             \
 114           __idx = (a) + (g) + (s) - 2;                          \
 115          ALLOC_##categ##_hst[((__idx > 4) ? 4 : __idx)] += 1;}
 116
 117 /* Some hard-to-account-for words are allocated by/for primitives,
 118  * includes Integer support.  ALLOC_PRIM2 tells us about these.  We
 119  * count everything as ``goods'', which is not strictly correct.
 120  * (ALLOC_PRIM is the same sort of stuff, but we know the
 121  * admin/goods/slop breakdown.)
 122  */
 123 #define TICK_ALLOC_PRIM(a,g,s)                          \
 124         ALLOC_PRIM_ctr++;       ALLOC_PRIM_adm += (a);  \
 125         ALLOC_PRIM_gds += (g);  ALLOC_PRIM_slp += (s);  \
 126         TICK_ALLOC_HISTO(PRIM,a,g,s)
 127
 128 #define TICK_ALLOC_PRIM2(w) ALLOC_PRIM_ctr++; ALLOC_PRIM_gds +=(w); \
 129                        TICK_ALLOC_HISTO(PRIM,0,w,0)
 130
 131
 132 /* -----------------------------------------------------------------------------
 133    Enters
 134    -------------------------------------------------------------------------- */
 135
 136 #define TICK_ENT_VIA_NODE()     ENT_VIA_NODE_ctr++
 137
 138 #define TICK_ENT_STATIC_THK()   ENT_STATIC_THK_ctr++
 139 #define TICK_ENT_DYN_THK()      ENT_DYN_THK_ctr++
 140
 141 typedef struct _StgEntCounter {
 142     unsigned    registeredp:16, /* 0 == no, 1 == yes */
 143                 arity:16,       /* arity (static info) */
 144                 stk_args:16;    /* # of args off stack */
 145                                 /* (rest of args are in registers) */
 146     char        *str;           /* name of the thing */
 147     char        *arg_kinds;     /* info about the args types */
 148     I_          entry_count;      /* Trips to fast entry code */
 149     I_          slow_entry_count; /* Trips to slow entry code */
 150     I_          allocs;         /* number of allocations by this fun */
 151     struct _StgEntCounter *link;/* link to chain them all together */
 152 } StgEntCounter;
 153
 154 #define TICK_CTR(f_ct, str, arity, args, arg_kinds)     \
 155    static StgEntCounter f_ct                    \
 156         = { 0, arity, args,                     \
 157             str, arg_kinds,                     \
 158             0, 0, 0, NULL };
 159
 160 /* The slow entry point for a function always goes to
 161    the fast entry point, which will register the stats block,
 162    so no need to do so here */
 163 #define TICK_ENT_STATIC_FUN_STD(f_ct)                           \
 164         f_ct.slow_entry_count++;                                \
 165         ENT_STATIC_FUN_STD_ctr++     /* The static total one */
 166
 167 #define TICK_ENT_DYN_FUN_STD(f_ct)                              \
 168         f_ct.slow_entry_count++;                                \
 169         ENT_DYN_FUN_STD_ctr++        /* The dynamic total one */
 170
 171 #define TICK_ENT_FUN_DIRECT_BODY(f_ct)                          \
 172         {                                                       \
 173           if ( ! f_ct.registeredp ) {                           \
 174             /* hook this one onto the front of the list */      \
 175             f_ct.link = ticky_entry_ctrs;                       \
 176             ticky_entry_ctrs = & (f_ct);                        \
 177             /* mark it as "registered" */                       \
 178             f_ct.registeredp = 1;                               \
 179           }                                                     \
 180           f_ct.entry_count += 1;                                \
 181         }                                                       \
 182
 183 #define TICK_ENT_STATIC_FUN_DIRECT(f_ct)                        \
 184         TICK_ENT_FUN_DIRECT_BODY(f_ct)                          \
 185         ENT_STATIC_FUN_DIRECT_ctr++ /* The static total one */
 186
 187 #define TICK_ENT_DYN_FUN_DIRECT(f_ct)                           \
 188         TICK_ENT_FUN_DIRECT_BODY(f_ct)                          \
 189         ENT_DYN_FUN_DIRECT_ctr++ /* The dynamic total one */
 190
 191 extern StgEntCounter top_ct;
 192 extern StgEntCounter *ticky_entry_ctrs;
 193
 194 #define TICK_ENT_STATIC_CON(n)  ENT_STATIC_CON_ctr++  /* enter static constructor */
 195 #define TICK_ENT_DYN_CON(n)     ENT_DYN_CON_ctr++     /* enter dynamic constructor */
 196 #define TICK_ENT_STATIC_IND(n)  ENT_STATIC_IND_ctr++  /* enter static indirection */
 197 #define TICK_ENT_DYN_IND(n)     ENT_DYN_IND_ctr++     /* enter dynamic indirection */
 198 #define TICK_ENT_PERM_IND(n)    ENT_PERM_IND_ctr++    /* enter permanent indirection */
 199 #define TICK_ENT_PAP(n)         ENT_PAP_ctr++         /* enter PAP */
 200 #define TICK_ENT_AP_UPD(n)      ENT_AP_UPD_ctr++      /* enter AP_UPD */
 201 #define TICK_ENT_BH()           ENT_BH_ctr++          /* enter BLACKHOLE */
 202
 203
 204 /* -----------------------------------------------------------------------------
 205    Returns
 206    -------------------------------------------------------------------------- */
 207
 208 /* Whenever a ``return'' occurs, it is returning the constituent parts of
 209  * a data constructor.  The parts can be returned either in registers, or
 210  * by allocating some heap to put it in (the TICK_ALLOC_* macros account for
 211  * the allocation).  The constructor can either be an existing one
 212  * *OLD* or we could have {\em just} figured out this stuff
 213  * *NEW*.
 214  */
 215
 216 #define TICK_RET_HISTO(categ,n)                                 \
 217         { I_ __idx;                                             \
 218           __idx = (n);                                          \
 219          RET_##categ##_hst[((__idx > 8) ? 8 : __idx)] += 1;}
 220
 221 #define TICK_RET_NEW(n) RET_NEW_ctr++; \
 222                         TICK_RET_HISTO(NEW,n)
 223
 224 #define TICK_RET_OLD(n) RET_OLD_ctr++; \
 225                         TICK_RET_HISTO(OLD,n)
 226
 227 #define TICK_RET_UNBOXED_TUP(n)  RET_UNBOXED_TUP_ctr++; \
 228                          TICK_RET_HISTO(UNBOXED_TUP,n)
 229
 230 #define TICK_RET_SEMI(n) RET_SEMI_IN_HEAP_ctr++; \
 231                          TICK_RET_HISTO(SEMI_IN_HEAP,n)
 232
 233 #define TICK_RET_SEMI_BY_DEFAULT()/*???*/ RET_SEMI_BY_DEFAULT_ctr++
 234
 235 #define TICK_RET_SEMI_FAILED(tag)       do {                            \
 236                                 if ((tag) == INFO_IND_TAG)              \
 237                                     RET_SEMI_FAILED_IND_ctr++;          \
 238                                 else                                    \
 239                                     RET_SEMI_FAILED_UNEVAL_ctr++;       \
 240                                 } while (0)
 241
 242 #define TICK_VEC_RETURN(n)      VEC_RETURN_ctr++;           \
 243                                 TICK_RET_HISTO(VEC_RETURN,n)
 244
 245 /* -----------------------------------------------------------------------------
 246    Stack Frames
 247
 248    Macro                           Counts
 249    ------------------              -------------------------------------------
 250    TICK_UPDF_PUSHED                Update frame pushed
 251    TICK_SEQF_PUSHED                Seq frame pushed
 252    TICK_CATCHF_PUSHED              Catch frame pushed
 253    TICK_UPDF_OMITTED               A thunk decided not to push an update frame
 254    TICK_UPDF_RCC_PUSHED            Cost Centre restore frame pushed
 255    TICK_UPDF_RCC_OMITTED           Cost Centres not required -- not pushed
 256
 257    -------------------------------------------------------------------------- */
 258
 259 #define TICK_UPDF_OMITTED()     UPDF_OMITTED_ctr++
 260 #define TICK_UPDF_PUSHED(tgt,inf)       UPDF_PUSHED_ctr++ \
 261 /*                              ; fprintf(stderr,"UPDF_PUSHED:%p:%p\n",tgt,inf) */
 262 #define TICK_SEQF_PUSHED()      SEQF_PUSHED_ctr++
 263 #define TICK_CATCHF_PUSHED()    CATCHF_PUSHED_ctr++
 264 #define TICK_UPDF_RCC_PUSHED()  UPDF_RCC_PUSHED_ctr++
 265 #define TICK_UPDF_RCC_OMITTED() UPDF_RCC_OMITTED_ctr++
 266
 267 /* -----------------------------------------------------------------------------
 268    Updates
 269
 270    These macros record information when we do an update.  We always
 271    update either with a data constructor (CON) or a partial application
 272    (PAP).
 273
 274
 275    Macro                                Where
 276    -----------------------      --------------------------------------------
 277    TICK_UPD_SQUEEZED            Same as UPD_EXISTING but because
 278                                 of stack-squeezing
 279    TICK_UPD_CON_IN_NEW          Allocating a new CON
 280    TICK_UPD_CON_IN_PLACE        Updating with a PAP in place
 281    TICK_UPD_PAP_IN_NEW          Allocating a new PAP
 282    TICK_UPD_PAP_IN_PLACE        Updating with a PAP in place
 283
 284    -------------------------------------------------------------------------- */
 285
 286 #define TICK_UPD_HISTO(categ,n) \
 287         { I_ __idx;                                              \
 288           __idx = (n);                                           \
 289          UPD_##categ##_hst[((__idx > 8) ? 8 : __idx)] += 1;}
 290
 291 #define TICK_UPD_SQUEEZED()             UPD_SQUEEZED_ctr++
 292
 293 #define TICK_UPD_CON_IN_NEW(n)          UPD_CON_IN_NEW_ctr++ ; \
 294                                         TICK_UPD_HISTO(CON_IN_NEW,n)
 295
 296 #define TICK_UPD_CON_IN_PLACE(n)        UPD_CON_IN_PLACE_ctr++; \
 297                                         TICK_UPD_HISTO(CON_IN_PLACE,n)
 298
 299 #define TICK_UPD_PAP_IN_NEW(n)          UPD_PAP_IN_NEW_ctr++ ; \
 300                                         TICK_UPD_HISTO(PAP_IN_NEW,n)
 301
 302 #define TICK_UPD_PAP_IN_PLACE()         UPD_PAP_IN_PLACE_ctr++
 303
 304 /* For the generational collector:
 305  */
 306 #define TICK_UPD_NEW_IND()              UPD_NEW_IND_ctr++
 307 #define TICK_UPD_NEW_PERM_IND(tgt)      UPD_NEW_PERM_IND_ctr++ \
 308 /*                                      ; fprintf(stderr,"UPD_NEW_PERM:%p\n",tgt) */
 309 #define TICK_UPD_OLD_IND()              UPD_OLD_IND_ctr++
 310 #define TICK_UPD_OLD_PERM_IND()         UPD_OLD_PERM_IND_ctr++
 311
 312 /* Count blackholes:
 313  */
 314 #define TICK_UPD_BH_UPDATABLE()         UPD_BH_UPDATABLE_ctr++
 315 #define TICK_UPD_BH_SINGLE_ENTRY()      UPD_BH_SINGLE_ENTRY_ctr++
 316 #define TICK_UPD_CAF_BH_UPDATABLE(s)                          \
 317      UPD_CAF_BH_UPDATABLE_ctr++                               \
 318 /*   ; fprintf(stderr,"TICK_UPD_CAF_BH_UPDATABLE(%s)\n",s) */
 319 #define TICK_UPD_CAF_BH_SINGLE_ENTRY(s)                       \
 320      UPD_CAF_BH_SINGLE_ENTRY_ctr++                            \
 321 /*   ; fprintf(stderr,"TICK_UPD_CAF_BH_SINGLE_ENTRY(%s)\n",s) */
 322
 323
 324 /* -----------------------------------------------------------------------------
 325    Garbage collection counters
 326    -------------------------------------------------------------------------- */
 327
 328 /* Selectors:
 329  *
 330  * GC_SEL_ABANDONED: we could've done the selection, but we gave up
 331  * (e.g., to avoid overflowing the C stack); GC_SEL_MINOR: did a
 332  * selection in a minor GC; GC_SEL_MAJOR: ditto, but major GC.
 333  */
 334 #define TICK_GC_SEL_ABANDONED()         GC_SEL_ABANDONED_ctr++
 335 #define TICK_GC_SEL_MINOR()             GC_SEL_MINOR_ctr++
 336 #define TICK_GC_SEL_MAJOR()             GC_SEL_MAJOR_ctr++
 337
 338 /* Failed promotion: we wanted to promote an object early, but
 339  * it had already been evacuated to (or resided in) a younger
 340  * generation.
 341  */
 342 #define TICK_GC_FAILED_PROMOTION()      GC_FAILED_PROMOTION_ctr++
 343
 344 /* Bytes copied: this is a fairly good measure of GC cost and depends
 345  * on all sorts of things like number of generations, aging, eager
 346  * promotion, generation sizing policy etc.
 347  */
 348 #define TICK_GC_WORDS_COPIED(n)         GC_WORDS_COPIED_ctr+=(n)
 349
 350 /* -----------------------------------------------------------------------------
 351    The accumulators (extern decls)
 352    -------------------------------------------------------------------------- */
 353
 354 #ifdef TICKY_C
 355 #define INIT(ializer) = ializer
 356 #define EXTERN
 357 #else
 358 #define INIT(ializer)
 359 #define EXTERN extern
 360 #endif
 361
 362 EXTERN unsigned long ALLOC_HEAP_ctr INIT(0);
 363 EXTERN unsigned long ALLOC_HEAP_tot INIT(0);
 364
 365 EXTERN unsigned long ALLOC_FUN_ctr INIT(0);
 366 EXTERN unsigned long ALLOC_FUN_adm INIT(0);
 367 EXTERN unsigned long ALLOC_FUN_gds INIT(0);
 368 EXTERN unsigned long ALLOC_FUN_slp INIT(0);
 369 EXTERN unsigned long ALLOC_FUN_hst[5]
 370 #ifdef TICKY_C
 371    = {0,0,0,0,0}  /* urk, can't use INIT macro 'cause of the commas */
 372 #endif
 373 ;
 374
 375 EXTERN unsigned long ALLOC_UP_THK_ctr INIT(0);
 376 EXTERN unsigned long ALLOC_SE_THK_ctr INIT(0);
 377 EXTERN unsigned long ALLOC_THK_adm INIT(0);
 378 EXTERN unsigned long ALLOC_THK_gds INIT(0);
 379 EXTERN unsigned long ALLOC_THK_slp INIT(0);
 380 EXTERN unsigned long ALLOC_THK_hst[5]
 381 #ifdef TICKY_C
 382    = {0,0,0,0,0}
 383 #endif
 384 ;
 385
 386 EXTERN unsigned long ALLOC_CON_ctr INIT(0);
 387 EXTERN unsigned long ALLOC_CON_adm INIT(0);
 388 EXTERN unsigned long ALLOC_CON_gds INIT(0);
 389 EXTERN unsigned long ALLOC_CON_slp INIT(0);
 390 EXTERN unsigned long ALLOC_CON_hst[5]
 391 #ifdef TICKY_C
 392    = {0,0,0,0,0}
 393 #endif
 394 ;
 395
 396 EXTERN unsigned long ALLOC_TUP_ctr INIT(0);
 397 EXTERN unsigned long ALLOC_TUP_adm INIT(0);
 398 EXTERN unsigned long ALLOC_TUP_gds INIT(0);
 399 EXTERN unsigned long ALLOC_TUP_slp INIT(0);
 400 EXTERN unsigned long ALLOC_TUP_hst[5]
 401 #ifdef TICKY_C
 402    = {0,0,0,0,0}
 403 #endif
 404 ;
 405
 406 EXTERN unsigned long ALLOC_BH_ctr INIT(0);
 407 EXTERN unsigned long ALLOC_BH_adm INIT(0);
 408 EXTERN unsigned long ALLOC_BH_gds INIT(0);
 409 EXTERN unsigned long ALLOC_BH_slp INIT(0);
 410 EXTERN unsigned long ALLOC_BH_hst[5]
 411 #ifdef TICKY_C
 412    = {0,0,0,0,0}
 413 #endif
 414 ;
 415
 416 EXTERN unsigned long ALLOC_PRIM_ctr INIT(0);
 417 EXTERN unsigned long ALLOC_PRIM_adm INIT(0);
 418 EXTERN unsigned long ALLOC_PRIM_gds INIT(0);
 419 EXTERN unsigned long ALLOC_PRIM_slp INIT(0);
 420 EXTERN unsigned long ALLOC_PRIM_hst[5]
 421 #ifdef TICKY_C
 422    = {0,0,0,0,0}
 423 #endif
 424 ;
 425
 426 EXTERN unsigned long ALLOC_UPD_PAP_ctr INIT(0);
 427 EXTERN unsigned long ALLOC_UPD_PAP_adm INIT(0);
 428 EXTERN unsigned long ALLOC_UPD_PAP_gds INIT(0);
 429 EXTERN unsigned long ALLOC_UPD_PAP_slp INIT(0);
 430 EXTERN unsigned long ALLOC_UPD_PAP_hst[5]
 431 #ifdef TICKY_C
 432    = {0,0,0,0,0}
 433 #endif
 434 ;
 435
 436 EXTERN unsigned long ALLOC_TSO_ctr INIT(0);
 437 EXTERN unsigned long ALLOC_TSO_adm INIT(0);
 438 EXTERN unsigned long ALLOC_TSO_gds INIT(0);
 439 EXTERN unsigned long ALLOC_TSO_slp INIT(0);
 440 EXTERN unsigned long ALLOC_TSO_hst[5]
 441 #ifdef TICKY_C
 442    = {0,0,0,0,0}
 443 #endif
 444 ;
 445
 446 # ifdef PAR
 447 EXTERN unsigned long ALLOC_FMBQ_ctr INIT(0);
 448 EXTERN unsigned long ALLOC_FMBQ_adm INIT(0);
 449 EXTERN unsigned long ALLOC_FMBQ_gds INIT(0);
 450 EXTERN unsigned long ALLOC_FMBQ_slp INIT(0);
 451 EXTERN unsigned long ALLOC_FMBQ_hst[5]
 452 #ifdef TICKY_C
 453    = {0,0,0,0,0}
 454 #endif
 455 ;
 456
 457 EXTERN unsigned long ALLOC_FME_ctr INIT(0);
 458 EXTERN unsigned long ALLOC_FME_adm INIT(0);
 459 EXTERN unsigned long ALLOC_FME_gds INIT(0);
 460 EXTERN unsigned long ALLOC_FME_slp INIT(0);
 461 EXTERN unsigned long ALLOC_FME_hst[5]
 462 #ifdef TICKY_C
 463    = {0,0,0,0,0}
 464 #endif
 465 ;
 466
 467 EXTERN unsigned long ALLOC_BF_ctr INIT(0);
 468 EXTERN unsigned long ALLOC_BF_adm INIT(0);
 469 EXTERN unsigned long ALLOC_BF_gds INIT(0);
 470 EXTERN unsigned long ALLOC_BF_slp INIT(0);
 471 EXTERN unsigned long ALLOC_BF_hst[5]
 472 #ifdef TICKY_C
 473    = {0,0,0,0,0}
 474 #endif
 475 ;
 476 #endif
 477
 478 EXTERN unsigned long ENT_VIA_NODE_ctr INIT(0);
 479 EXTERN unsigned long ENT_STATIC_THK_ctr INIT(0);
 480 EXTERN unsigned long ENT_DYN_THK_ctr INIT(0);
 481 EXTERN unsigned long ENT_STATIC_FUN_STD_ctr INIT(0);
 482 EXTERN unsigned long ENT_DYN_FUN_STD_ctr INIT(0);
 483 EXTERN unsigned long ENT_STATIC_FUN_DIRECT_ctr INIT(0);
 484 EXTERN unsigned long ENT_DYN_FUN_DIRECT_ctr INIT(0);
 485 EXTERN unsigned long ENT_STATIC_CON_ctr INIT(0);
 486 EXTERN unsigned long ENT_DYN_CON_ctr INIT(0);
 487 EXTERN unsigned long ENT_STATIC_IND_ctr INIT(0);
 488 EXTERN unsigned long ENT_DYN_IND_ctr INIT(0);
 489 EXTERN unsigned long ENT_PERM_IND_ctr INIT(0);
 490 EXTERN unsigned long ENT_PAP_ctr INIT(0);
 491 EXTERN unsigned long ENT_AP_UPD_ctr INIT(0);
 492 EXTERN unsigned long ENT_BH_ctr INIT(0);
 493
 494 EXTERN unsigned long RET_NEW_ctr INIT(0);
 495 EXTERN unsigned long RET_OLD_ctr INIT(0);
 496 EXTERN unsigned long RET_UNBOXED_TUP_ctr INIT(0);
 497 EXTERN unsigned long RET_SEMI_BY_DEFAULT_ctr INIT(0);
 498 EXTERN unsigned long RET_SEMI_IN_HEAP_ctr INIT(0);
 499 EXTERN unsigned long RET_SEMI_FAILED_IND_ctr INIT(0);
 500 EXTERN unsigned long RET_SEMI_FAILED_UNEVAL_ctr INIT(0);
 501
 502 EXTERN unsigned long VEC_RETURN_ctr INIT(0);
 503
 504 EXTERN unsigned long RET_NEW_hst[9]
 505 #ifdef TICKY_C
 506    = {0,0,0,0,0,0,0,0,0}
 507 #endif
 508 ;
 509 EXTERN unsigned long RET_OLD_hst[9]
 510 #ifdef TICKY_C
 511    = {0,0,0,0,0,0,0,0,0}
 512 #endif
 513 ;
 514 EXTERN unsigned long RET_UNBOXED_TUP_hst[9]
 515 #ifdef TICKY_C
 516    = {0,0,0,0,0,0,0,0,0}
 517 #endif
 518 ;
 519 EXTERN unsigned long RET_SEMI_IN_HEAP_hst[9]
 520 #ifdef TICKY_C
 521    = {0,0,0,0,0,0,0,0,0}
 522 #endif
 523 ;
 524 EXTERN unsigned long RET_VEC_RETURN_hst[9]
 525 #ifdef TICKY_C
 526    = {0,0,0,0,0,0,0,0,0}
 527 #endif
 528 ;
 529
 530 EXTERN unsigned long RET_SEMI_loads_avoided INIT(0);
 531
 532 EXTERN unsigned long UPDF_OMITTED_ctr INIT(0);
 533 EXTERN unsigned long UPDF_PUSHED_ctr INIT(0);
 534 EXTERN unsigned long SEQF_PUSHED_ctr INIT(0);
 535 EXTERN unsigned long CATCHF_PUSHED_ctr INIT(0);
 536 EXTERN unsigned long UPDF_RCC_PUSHED_ctr INIT(0);
 537 EXTERN unsigned long UPDF_RCC_OMITTED_ctr INIT(0);
 538
 539 EXTERN unsigned long UPD_SQUEEZED_ctr INIT(0);
 540 EXTERN unsigned long UPD_CON_IN_NEW_ctr INIT(0);
 541 EXTERN unsigned long UPD_CON_IN_PLACE_ctr INIT(0);
 542 EXTERN unsigned long UPD_PAP_IN_NEW_ctr INIT(0);
 543 EXTERN unsigned long UPD_PAP_IN_PLACE_ctr INIT(0);
 544
 545 EXTERN unsigned long UPD_CON_IN_NEW_hst[9]
 546 #ifdef TICKY_C
 547    = {0,0,0,0,0,0,0,0,0}
 548 #endif
 549 ;
 550 EXTERN unsigned long UPD_CON_IN_PLACE_hst[9]
 551 #ifdef TICKY_C
 552    = {0,0,0,0,0,0,0,0,0}
 553 #endif
 554 ;
 555 EXTERN unsigned long UPD_PAP_IN_NEW_hst[9]
 556 #ifdef TICKY_C
 557    = {0,0,0,0,0,0,0,0,0}
 558 #endif
 559 ;
 560
 561 EXTERN unsigned long UPD_NEW_IND_ctr INIT(0);
 562 EXTERN unsigned long UPD_NEW_PERM_IND_ctr INIT(0);
 563 EXTERN unsigned long UPD_OLD_IND_ctr INIT(0);
 564 EXTERN unsigned long UPD_OLD_PERM_IND_ctr INIT(0);
 565
 566 EXTERN unsigned long UPD_BH_UPDATABLE_ctr INIT(0);
 567 EXTERN unsigned long UPD_BH_SINGLE_ENTRY_ctr INIT(0);
 568 EXTERN unsigned long UPD_CAF_BH_UPDATABLE_ctr INIT(0);
 569 EXTERN unsigned long UPD_CAF_BH_SINGLE_ENTRY_ctr INIT(0);
 570
 571 EXTERN unsigned long GC_SEL_ABANDONED_ctr INIT(0);
 572 EXTERN unsigned long GC_SEL_MINOR_ctr INIT(0);
 573 EXTERN unsigned long GC_SEL_MAJOR_ctr INIT(0);
 574
 575 EXTERN unsigned long GC_FAILED_PROMOTION_ctr INIT(0);
 576
 577 EXTERN unsigned long GC_WORDS_COPIED_ctr INIT(0);
 578
 579 #undef INIT
 580 #undef EXTERN
 581
 582 /* -----------------------------------------------------------------------------
 583    Just stubs if no ticky-ticky profiling
 584    -------------------------------------------------------------------------- */
 585
 586 #else /* !TICKY_TICKY */
 587
 588 #define TICK_ALLOC_HEAP(words, f_ct)
 589 #define TICK_ALLOC_HEAP_NOCTR(words)
 590
 591 #define TICK_ALLOC_FUN(g,s)
 592 #define TICK_ALLOC_UP_THK(g,s)
 593 #define TICK_ALLOC_SE_THK(g,s)
 594 #define TICK_ALLOC_CON(g,s)
 595 #define TICK_ALLOC_TUP(g,s)
 596 #define TICK_ALLOC_BH(g,s)
 597 #define TICK_ALLOC_UPD_PAP(g,s)
 598 #define TICK_ALLOC_TSO(g,s)
 599 #define TICK_ALLOC_FMBQ(a,g,s)
 600 #define TICK_ALLOC_FME(a,g,s)
 601 #define TICK_ALLOC_BF(a,g,s)
 602 #define TICK_ALLOC_PRIM(a,g,s)
 603 #define TICK_ALLOC_PRIM2(w)
 604
 605 #define TICK_ENT_VIA_NODE()
 606
 607 #define TICK_ENT_STATIC_THK()
 608 #define TICK_ENT_DYN_THK()
 609 #define TICK_ENT_STATIC_FUN_STD(n)
 610 #define TICK_ENT_DYN_FUN_STD(n)
 611 #define TICK_ENT_STATIC_FUN_DIRECT(n)
 612 #define TICK_ENT_DYN_FUN_DIRECT(n)
 613
 614 #define TICK_ENT_STATIC_CON(n)
 615 #define TICK_ENT_DYN_CON(n)
 616 #define TICK_ENT_STATIC_IND(n)
 617 #define TICK_ENT_DYN_IND(n)
 618 #define TICK_ENT_PERM_IND(n)
 619 #define TICK_ENT_PAP(n)
 620 #define TICK_ENT_AP_UPD(n)
 621 #define TICK_ENT_BH()
 622
 623 #define TICK_RET_NEW(n)
 624 #define TICK_RET_OLD(n)
 625 #define TICK_RET_UNBOXED_TUP(n)
 626 #define TICK_RET_SEMI(n)
 627 #define TICK_RET_SEMI_BY_DEFAULT()
 628 #define TICK_RET_SEMI_FAILED(tag)
 629 #define TICK_VEC_RETURN(n)
 630
 631 #define TICK_UPDF_OMITTED()
 632 #define TICK_UPDF_PUSHED(tgt,inf)
 633 #define TICK_SEQF_PUSHED()
 634 #define TICK_CATCHF_PUSHED()
 635 #define TICK_UPDF_RCC_PUSHED()
 636 #define TICK_UPDF_RCC_OMITTED()
 637
 638 #define TICK_UPD_SQUEEZED()
 639 #define TICK_UPD_CON_IN_NEW(n)
 640 #define TICK_UPD_CON_IN_PLACE(n)
 641 #define TICK_UPD_PAP_IN_NEW(n)
 642 #define TICK_UPD_PAP_IN_PLACE()
 643
 644 #define TICK_UPD_NEW_IND()
 645 #define TICK_UPD_NEW_PERM_IND(tgt)
 646 #define TICK_UPD_OLD_IND()
 647 #define TICK_UPD_OLD_PERM_IND()
 648
 649 #define TICK_UPD_BH_UPDATABLE()
 650 #define TICK_UPD_BH_SINGLE_ENTRY()
 651 #define TICK_UPD_CAF_BH_UPDATABLE()
 652 #define TICK_UPD_CAF_BH_SINGLE_ENTRY()
 653
 654 #define TICK_GC_SEL_ABANDONED()
 655 #define TICK_GC_SEL_MINOR()
 656 #define TICK_GC_SEL_MAJOR()
 657
 658 #define TICK_GC_FAILED_PROMOTION()
 659 #define TICK_GC_WORDS_COPIED(n)
 660
 661 #endif /* !TICKY_TICKY */
 662
 663 #endif /* TICKY_H */