ghc/includes/StgTicky.h

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