ghc/includes/StgTicky.h

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