includes/StgTicky.h

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