+++ /dev/null
-%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1995
-%
-%************************************************************************
-%* *
-\section[RednCounts.lh]{Interface (and macros) for reduction-count statistics}
-%* *
-%************************************************************************
-
-Multi-slurp protection:
-\begin{code}
-#ifndef REDNCOUNTS_H
-#define REDNCOUNTS_H
-\end{code}
-
-There are macros in here for:
-\begin{enumerate}
-\item
-``SPAT-profiling'' (\tr{DO_SPAT_PROFILING}), counting instructions
-per ``activity,'' using the SPAT instruction-trace analysis tools.
-\item
-``Ticky-ticky profiling'' (\tr{DO_REDN_COUNTING}), counting the
-number of various STG-events (updates, enters, etc.)
-
-This file goes with \tr{RednCounts.lc}, which initialises the counters
-and does the printing [ticky-ticky only].
-
-%************************************************************************
-%* *
-\subsection[SPAT-macros]{Macros for SPAT instruction counting}
-%* *
-%************************************************************************
-
-These definitions are for instruction tracing, e.g. using SPAT on the
-SPARC.
-
-\begin{code}
-#ifdef DO_SPAT_PROFILING
-
-#define ACT_BASE 0x000000ab /* random; to fit in 13 bits */
-
-#define ACT_UNKNOWN (0+ACT_BASE)
-#define ACT_GC (1+ACT_BASE)
-#define ACT_REDN (2+ACT_BASE)
-#define ACT_ASTK_STUB (3+ACT_BASE)
-#define ACT_FILL_IN_HEAP (4+ACT_BASE)
-#define ACT_HEAP_CHK (5+ACT_BASE)
-#define ACT_RETURN (6+ACT_BASE)
-#define ACT_UPDATE (7+ACT_BASE)
-#define ACT_PUSH_UPDF (8+ACT_BASE)
-#define ACT_ARGS_CHK (9+ACT_BASE)
-#define ACT_UPDATE_PAP (10+ACT_BASE)
-#define ACT_INDIRECT (11+ACT_BASE)
-#define ACT_PRIM (12+ACT_BASE)
-
-#define ACT_OVERHEAD (14+ACT_BASE) /* only used in analyser */
-#define ACT_TAILCALL (15+ACT_BASE)
- /* Note: quite a lot gets lumped under TAILCALL; the analyser
- untangles it with other info. WDP 95/01
- */
-
-#define ACTIVITIES 16
-
-#define ACT_GC_STOP (ACTIVITIES+1)
-#define ACT_PRIM_STOP (ACTIVITIES+2)
-
-/* values that "signal" the start/stop of something,
- thus suggesting to the analyser that it stop/start something.
-
- I do not think they are used (WDP 95/01)
-*/
-
-#define ACT_SIGNAL_BASE 0xbababa00 /* pretty random; yes */
-
-#define ACT_START_GOING (1+ACT_SIGNAL_BASE)
-#define ACT_STOP_GOING (2+ACT_SIGNAL_BASE)
-#define ACT_START_GC (3+ACT_SIGNAL_BASE)
-#define ACT_STOP_GC (4+ACT_SIGNAL_BASE)
-
-#define SET_ACTIVITY(act) do { /* ActivityReg = (act) */ \
- __asm__ volatile ("or %%g0,%1,%0" \
- : "=r" (ActivityReg) \
- : "I" (act)); \
- } while(0)
-
-#define ALLOC_HEAP(n) /* nothing */
-#define UN_ALLOC_HEAP(n) /* nothing */
-#define DO_ASTK_HWM() /* nothing */
-#define DO_BSTK_HWM() /* nothing */
-
-#define A_STK_STUB(n) /* nothing */
-#define A_STK_REUSE(n) /* not used at all */
-#define B_STK_REUSE(n) /* ditto */
-
-#define ALLOC_FUN(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_THK(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_CON(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_TUP(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_BH(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-/*#define ALLOC_PAP(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP)*/
-#define ALLOC_UPD_PAP(a,g,s,t) SET_ACTIVITY(ACT_UPDATE_PAP) /* NB */
-/*#define ALLOC_UPD_CON(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP) */
-#define ALLOC_PRIM(a,g,s,t) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_PRIM2(w) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_STK(a,g,s) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_TSO(a,g,s) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_FMBQ(a,g,s) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_FME(a,g,s) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-#define ALLOC_BF(a,g,s) SET_ACTIVITY(ACT_FILL_IN_HEAP)
-
-/* we only use the ENT_ macros to be sure activity is set to "reduction" */
-#define ENT_VIA_NODE() /* nothing */
-#define ENT_THK() SET_ACTIVITY(ACT_REDN)
-#define ENT_FUN_STD() SET_ACTIVITY(ACT_REDN)
-#define ENT_FUN_DIRECT(f,f_str,f_arity,Aargs,Bargs,arg_kinds,wrap,wrap_kinds) \
- SET_ACTIVITY(ACT_REDN)
-#define ENT_CON(n) SET_ACTIVITY(ACT_REDN)
-#define ENT_IND(n) SET_ACTIVITY(ACT_REDN)
-#define ENT_PAP(n) SET_ACTIVITY(ACT_UPDATE_PAP) /* NB */
-
-#define RET_NEW_IN_HEAP() SET_ACTIVITY(ACT_RETURN)
-#define RET_NEW_IN_REGS() SET_ACTIVITY(ACT_RETURN)
-#define RET_OLD_IN_HEAP() SET_ACTIVITY(ACT_RETURN)
-#define RET_OLD_IN_REGS() SET_ACTIVITY(ACT_RETURN)
-#define RET_SEMI_BY_DEFAULT() SET_ACTIVITY(ACT_RETURN)
-#define RET_SEMI_IN_HEAP() SET_ACTIVITY(ACT_RETURN)
-#define RET_SEMI_IN_REGS() SET_ACTIVITY(ACT_RETURN)
-#define VEC_RETURN() /* nothing */
-
-#define UPDF_OMITTED() /* nothing (set directly by PUSH_STD_UPD_FRAME) */
-#define UPDF_STD_PUSHED() SET_ACTIVITY(ACT_PUSH_UPDF)
-#define UPDF_CON_PUSHED() /* nothing */
-#define UPDF_HOLE_PUSHED() /* nothing */
-#define UPDF_RCC_PUSHED() /* nothing */
-#define UPDF_RCC_OMITTED() /* nothing */
-
-#define UPD_EXISTING() /* nothing -- used in .lc code */
-#define UPD_CON_W_NODE() SET_ACTIVITY(ACT_UPDATE)
-#define UPD_CON_IN_PLACE() SET_ACTIVITY(ACT_UPDATE)
-#define UPD_PAP_IN_PLACE() /* nothing -- UpdatePAP has its own activity */
-#define UPD_CON_IN_NEW() SET_ACTIVITY(ACT_UPDATE)
-#define UPD_PAP_IN_NEW() /* nothing -- UpdatePAP has its own activity */
-\end{code}
-
-For special subsequent enter counting:
-\begin{code}
-#define UPDATED_SET_UPDATED(n) /* nothing */
-#define ENTERED_CHECK_UPDATED(n) /* nothing */
-\end{code}
-
-For a generational collector:
-\begin{code}
-#define UPD_NEW_IND() /* nothing (set elsewhere [?]) */
-#define UPD_NEW_IN_PLACE_PTRS() /* nothing */
-#define UPD_NEW_IN_PLACE_NOPTRS() /* nothing */
-#define UPD_OLD_IND() /* nothing */
-#define UPD_OLD_IN_PLACE_PTRS() /* nothing */
-#define UPD_OLD_IN_PLACE_NOPTRS() /* nothing */
-
-#endif /* DO_SPAT_PROFILING */
-\end{code}
-
-%************************************************************************
-%* *
-\subsection[ticky-ticky-macros]{Stuff for ``ticky-ticky'' profiling}
-%* *
-%************************************************************************
-
-\begin{code}
-#ifdef DO_REDN_COUNTING
-
-#define SET_ACTIVITY(act) /* quickly: make this do NOTHING */
-\end{code}
-
-Measure what proportion of ...:
-\begin{itemize}
-\item
-... Enters are to data values, function values, thunks.
-\item
-... allocations are for data values, functions values, thunks.
-\item
-... updates are for data values, function values.
-\item
-... updates ``fit''
-\item
-... return-in-heap (dynamic)
-\item
-... vectored return (dynamic)
-\item
-... updates are wasted (never re-entered).
-\item
-... constructor returns get away without hitting an update.
-\end{enumerate}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-stk-heap-use]{Stack and heap usage}
-%* *
-%************************************************************************
-
-Things we are interested in here:
-\begin{itemize}
-\item
-How many times we do a heap check and move @Hp@; comparing this with
-the allocations gives an indication of how many things we get per trip
-to the well:
-\begin{code}
-#define ALLOC_HEAP(n) ALLOC_HEAP_ctr++; ALLOC_HEAP_tot += (n)
-\end{code}
-
-If we do a ``heap lookahead,'' we haven't really allocated any
-heap, so we need to undo the effects of an \tr{ALLOC_HEAP}:
-\begin{code}
-#define UN_ALLOC_HEAP(n) ALLOC_HEAP_ctr--; ALLOC_HEAP_tot -= (n)
-\end{code}
-
-\item
-The stack high-water marks. This is {\em direction-sensitive}!!
-(A stack grows downward, B stack upwards)
-\begin{code}
-#ifndef CONCURRENT
-#define DO_ASTK_HWM() if (SpA < max_SpA) { max_SpA = SpA; }
-#define DO_BSTK_HWM() if (SpB > max_SpB) { max_SpB = SpB; }
-#else
-/*
- * This is not direction sensitive, because we threads people are well-behaved.
- * However, it might be a good idea to cache the constant bits (DEP + BOT and
- * HWM) from the STKO and TSO in more readily accessible places. -- ToDo!
- */
-#define DO_ASTK_HWM() { \
- I_ depth = STKO_ADEP(StkOReg) + AREL((I_) STKO_ASTK_BOT(StkOReg) - (I_) SpA);\
- if (depth > TSO_AHWM(CurrentTSO)) \
- TSO_AHWM(CurrentTSO) = depth; \
-}
-#define DO_BSTK_HWM() { \
- I_ depth = STKO_BDEP(StkOReg) + BREL((I_) STKO_BSTK_BOT(StkOReg) - (I_) SpB);\
- if (depth > TSO_BHWM(CurrentTSO)) \
- TSO_BHWM(CurrentTSO) = depth; \
-}
-#endif
-\end{code}
-
-\item
-Re-use of stack slots, and stubbing of stack slots:
-\begin{code}
-#define A_STK_STUB(n) A_STK_STUB_ctr += (n)
-#define A_STK_REUSE(n) A_STK_REUSE_ctr += (n) /* not used at all? */
-#define B_STK_REUSE(n) B_STK_REUSE_ctr += (n) /* not used at all? */
-\end{code}
-\end{itemize}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-allocs]{Allocations}
-%* *
-%************************************************************************
-
-We count things every time we allocate something in the dynamic heap.
-For each, we count the number of words of (1)~``admin'' (header),
-(2)~good stuff (useful pointers and data), and (3)~``slop'' (extra
-space, in hopes it will allow an in-place update).
-
-The first five macros are inserted when the compiler generates code
-to allocate something; the categories correspond to the @ClosureClass@
-datatype (manifest functions, thunks, constructors, big tuples, and
-partial applications).
-\begin{code}
-#define ALLOC_FUN(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_FUN_ctr++; ALLOC_FUN_adm += (a); \
- ALLOC_FUN_gds += (g); ALLOC_FUN_slp += (s); \
- ALLOC_HISTO(FUN,a,g,s)
-#define ALLOC_THK(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_THK_ctr++; ALLOC_THK_adm += (a); \
- ALLOC_THK_gds += (g); ALLOC_THK_slp += (s); \
- ALLOC_HISTO(THK,a,g,s)
-#define ALLOC_CON(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_CON_ctr++; ALLOC_CON_adm += (a); \
- ALLOC_CON_gds += (g); ALLOC_CON_slp += (s); \
- ALLOC_HISTO(CON,a,g,s)
-#define ALLOC_TUP(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_TUP_ctr++; ALLOC_TUP_adm += (a); \
- ALLOC_TUP_gds += (g); ALLOC_TUP_slp += (s); \
- ALLOC_HISTO(TUP,a,g,s)
-#define ALLOC_BH(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_BH_ctr++; ALLOC_BH_adm += (a); \
- ALLOC_BH_gds += (g); ALLOC_BH_slp += (s); \
- ALLOC_HISTO(BH,a,g,s)
-#if 0
-#define ALLOC_PAP(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_PAP_ctr++; ALLOC_PAP_adm += (a); \
- ALLOC_PAP_gds += (g); ALLOC_PAP_slp += (s); \
- ALLOC_HISTO(PAP,a,g,s)
-#endif
-\end{code}
-
-We may also allocate space when we do an update, and there isn't
-enough space. These macros suffice (for: updating with a partial
-application and a constructor):
-\begin{code}
-#define ALLOC_UPD_PAP(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_UPD_PAP_ctr++; ALLOC_UPD_PAP_adm += (a); \
- ALLOC_UPD_PAP_gds += (g); ALLOC_UPD_PAP_slp += (s); \
- ALLOC_HISTO(UPD_PAP,a,g,s)
-#if 0
-#define ALLOC_UPD_CON(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_UPD_CON_ctr++; ALLOC_UPD_CON_adm += (a); \
- ALLOC_UPD_CON_gds += (g); ALLOC_UPD_CON_slp += (s); \
- ALLOC_HISTO(UPD_CON,a,g,s)
-#endif /* 0 */
-\end{code}
-
-In the threaded world, we allocate space for the spark pool, stack objects,
-and thread state objects.
-
-\begin{code}
-
-#define ALLOC_STK(a,g,s) ALLOC_STK_ctr++; ALLOC_STK_adm += (a); \
- ALLOC_STK_gds += (g); ALLOC_STK_slp += (s); \
- ALLOC_HISTO(STK,a,g,s)
-
-#define ALLOC_TSO(a,g,s) ALLOC_TSO_ctr++; ALLOC_TSO_adm += (a); \
- ALLOC_TSO_gds += (g); ALLOC_TSO_slp += (s); \
- ALLOC_HISTO(TSO,a,g,s)
-
-#define ALLOC_FMBQ(a,g,s) ALLOC_FMBQ_ctr++; ALLOC_FMBQ_adm += (a); \
- ALLOC_FMBQ_gds += (g); ALLOC_FMBQ_slp += (s); \
- ALLOC_HISTO(FMBQ,a,g,s)
-
-#define ALLOC_FME(a,g,s) ALLOC_FME_ctr++; ALLOC_FME_adm += (a); \
- ALLOC_FME_gds += (g); ALLOC_FME_slp += (s); \
- ALLOC_HISTO(FME,a,g,s)
-
-#define ALLOC_BF(a,g,s) ALLOC_BF_ctr++; ALLOC_BF_adm += (a); \
- ALLOC_BF_gds += (g); ALLOC_BF_slp += (s); \
- ALLOC_HISTO(BF,a,g,s)
-
-\end{code}
-
-The histogrammy bit is fairly straightforward; the \tr{-2} is: one for
-0-origin C arrays; the other one because we do {\em no} one-word
-allocations, so we would never inc that histogram slot; so we shift
-everything over by one.
-\begin{code}
-#define ALLOC_HISTO(categ,a,g,s) \
- { I_ __idx; \
- __idx = (a) + (g) + (s) - 2; \
- CAT3(ALLOC_,categ,_hst)[((__idx > 4) ? 4 : __idx)] += 1;}
-\end{code}
-
-Some hard-to-account-for words are allocated by/for primitives,
-includes Integer support. @ALLOC_PRIM2@ tells us about these. We
-count everything as ``goods'', which is not strictly correct.
-(@ALLOC_PRIM@ is the same sort of stuff, but we know the
-admin/goods/slop breakdown.)
-\begin{code}
-#define ALLOC_PRIM(a,g,s,t) ASSERT((t) == (a)+(g)+(s)); \
- ALLOC_PRIM_ctr++; ALLOC_PRIM_adm += (a); \
- ALLOC_PRIM_gds += (g); ALLOC_PRIM_slp += (s); \
- ALLOC_HISTO(PRIM,a,g,s)
-#define ALLOC_PRIM2(w) ALLOC_PRIM_ctr++; ALLOC_PRIM_gds +=(w); \
- ALLOC_HISTO(PRIM,0,w,0)
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-enters]{Enters}
-%* *
-%************************************************************************
-
-\begin{code}
-#define ENT_VIA_NODE() ENT_VIA_NODE_ctr++ /* via ENT_ macro */
-
-#define ENT_THK() ENT_THK_ctr++
-#define ENT_FUN_STD() ENT_FUN_STD_ctr++ /* manifest fun; std entry pt */
-
-#define ENT_CON(n) ENTERED_CHECK_UPDATED(n); ENT_CON_ctr++ /* enter code for constructor */
-#define ENT_IND(n) ENTERED_CHECK_UPDATED(n); ENT_IND_ctr++ /* enter indirection */
-#define ENT_PAP(n) ENTERED_CHECK_UPDATED(n); ENT_PAP_ctr++ /* enter partial application */
-\end{code}
-
-We do more magical things with @ENT_FUN_DIRECT@. Besides simply knowing
-how many ``fast-entry-point'' enters there were, we'd like {\em simple}
-information about where those enters were, and the properties thereof.
-\begin{code}
-struct ent_counter {
- unsigned registeredp:16, /* 0 == no, 1 == yes */
- arity:16, /* arity (static info) */
- Astk_args:16, /* # of args off A stack */
- Bstk_args:16; /* # of args off B stack */
- /* (rest of args are in registers) */
- StgChar *f_str; /* name of the thing */
- StgChar *f_arg_kinds; /* info about the args types */
- StgChar *wrap_str; /* name of its wrapper (if any) */
- StgChar *wrap_arg_kinds;/* info about the orig wrapper's arg types */
- I_ ctr; /* the actual counter */
- struct ent_counter *link; /* link to chain them all together */
-};
-
-/* OLD: extern void RegisterEntryPt PROTO((struct ent_counter *)); */
-extern struct ent_counter *ListOfEntryCtrs;
-
-#define ENT_FUN_DIRECT(f_ct,f_str,f_arity,Aargs,Bargs,arg_kinds,wrap,wrap_kinds) \
- static struct ent_counter f_ct \
- = { 0, \
- (f_arity), (Aargs), (Bargs), (f_str), (arg_kinds),\
- (wrap), (wrap_kinds), \
- 0, NULL }; \
- if ( ! f_ct.registeredp ) { \
- /* hook this one onto the front of the list */ \
- f_ct.link = ListOfEntryCtrs; \
- ListOfEntryCtrs = & (f_ct); \
- \
- /* mark it as "registered" */ \
- f_ct.registeredp = 1; \
- } \
- f_ct.ctr += 1; \
- ENT_FUN_DIRECT_ctr++ /* the old boring one */
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-returns]{Returns}
-%* *
-%************************************************************************
-
-Whenever a ``return'' occurs, it is returning the constituent parts of
-a data constructor. The parts can be returned either in registers, or
-by allocating some heap to put it in (the @ALLOC_*@ macros account for
-the allocation). The constructor can either be an existing one
-(\tr{*OLD*}) or we could have {\em just} figured out this stuff
-(\tr{*NEW*}).
-
-Here's some special magic that Simon wants [edited to match names
-actually used]:
-\begin{display}
-From: Simon L Peyton Jones <simonpj>
-To: partain, simonpj
-Subject: counting updates
-Date: Wed, 25 Mar 92 08:39:48 +0000
-
-I'd like to count how many times we update in place when actually Node
-points to the thing. Here's how:
-
-\tr{RET_OLD_IN_REGS} sets the variable \tr{ReturnInRegsNodeValid} to \tr{True};
-\tr{RET_NEW_IN_REGS} sets it to \tr{False}.
-
-\tr{RET_SEMI_???} sets it to??? ToDo [WDP]
-
-\tr{UPD_CON_IN_PLACE} tests the variable, and increments \tr{UPD_IN_PLACE_COPY_ctr}
-if it is true.
-
-Then we need to report it along with the update-in-place info.
-\end{display}
-
-\begin{code}
-#define RET_NEW_IN_HEAP() RET_NEW_IN_HEAP_ctr++
-#define RET_OLD_IN_HEAP() RET_OLD_IN_HEAP_ctr++
-
-#define RET_NEW_IN_REGS() RET_NEW_IN_REGS_ctr++; \
- ReturnInRegsNodeValid = 0
-#define RET_OLD_IN_REGS() RET_OLD_IN_REGS_ctr++; \
- ReturnInRegsNodeValid = 1
-
-#define RET_SEMI_BY_DEFAULT() RET_SEMI_BY_DEFAULT_ctr++
-#define RET_SEMI_IN_HEAP() RET_SEMI_IN_HEAP_ctr++
-#define RET_SEMI_IN_REGS() RET_SEMI_IN_REGS_ctr++
-\end{code}
-
-Of all the returns (sum of four categories above), how many were
-vectored? (The rest were obviously unvectored).
-\begin{code}
-#define VEC_RETURN() VEC_RETURN_ctr++
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-update-frames]{Update frames}
-%* *
-%************************************************************************
-
-These macros count up the following update information.
-
-%partain:\begin{center}
-\begin{tabular}{ll} \hline
-Macro & Counts \\ \hline
- & \\
-\tr{UPDF_STD_PUSHED} & Update frame pushed \\
-\tr{UPDF_CON_PUSHED} & Constructor update frame pushed \\
-\tr{UPDF_HOLE_PUSHED} & An update frame to update a black hole \\
-\tr{UPDF_OMITTED} & A thunk decided not to push an update frame \\
- & (all subsets of \tr{ENT_THK}) \\
-\tr{UPDF_RCC_PUSHED} & Cost Centre restore frame pushed \\
-\tr{UPDF_RCC_OMITTED} & Cost Centres not required -- not pushed \\\hline
-\end{tabular}
-%partain:\end{center}
-
-\begin{code}
-#define UPDF_OMITTED() UPDF_OMITTED_ctr++
-
-#define UPDF_STD_PUSHED() UPDF_STD_PUSHED_ctr++
-#define UPDF_CON_PUSHED() UPDF_CON_PUSHED_ctr++
-#define UPDF_HOLE_PUSHED() UPDF_HOLE_PUSHED_ctr++
-
-#define UPDF_RCC_PUSHED() UPDF_RCC_PUSHED_ctr++
-#define UPDF_RCC_OMITTED() UPDF_RCC_OMITTED_ctr++
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-updates]{Updates}
-%* *
-%************************************************************************
-
-These macros record information when we do an update. We always
-update either with a data constructor (CON) or a partial application
-(PAP).
-
-%partain:\begin{center}
-\begin{tabular}{|l|l|}\hline
-Macro & Where \\ \hline
- & \\
-\tr{UPD_EXISTING} & Updating with an indirection to something \\
- & already in the heap \\
-
-\tr{UPD_CON_W_NODE} & Updating with a CON: by indirecting to Node \\
-
-\tr{UPD_CON_IN_PLACE} & Ditto, but in place \\
-\tr{UPD_CON_IN_NEW} & Ditto, but allocating the object \\
-
-\tr{UPD_PAP_IN_PLACE} & Same, but updating w/ a PAP \\
-\tr{UPD_PAP_IN_NEW} & \\\hline
-\end{tabular}
-%partain:\end{center}
-
-\begin{code}
-#define UPD_EXISTING() UPD_EXISTING_ctr++
-
-#define UPD_CON_W_NODE() UPD_CON_W_NODE_ctr++
-
-#define UPD_CON_IN_NEW() UPD_CON_IN_NEW_ctr++
-#define UPD_PAP_IN_NEW() UPD_PAP_IN_NEW_ctr++
-/* ToDo: UPD_NEW_COPY_ctr, as below */
-
-#define UPD_CON_IN_PLACE() UPD_CON_IN_PLACE_ctr++ ; \
- UPD_IN_PLACE_COPY_ctr += ReturnInRegsNodeValid
- /* increments if True; otherwise, no */
-#define UPD_PAP_IN_PLACE() UPD_PAP_IN_PLACE_ctr++ ; \
- UPD_IN_PLACE_COPY_ctr += ReturnInRegsNodeValid
- /* increments if True; otherwise, no */
-\end{code}
-
-For a generational collector:
-\begin{code}
-#define UPD_NEW_IND() UPD_NEW_IND_ctr++;
-#define UPD_NEW_IN_PLACE_PTRS() UPD_NEW_IN_PLACE_PTRS_ctr++;
-#define UPD_NEW_IN_PLACE_NOPTRS() UPD_NEW_IN_PLACE_NOPTRS_ctr++;
-#define UPD_OLD_IND() UPD_OLD_IND_ctr++;
-#define UPD_OLD_IN_PLACE_PTRS() UPD_OLD_IN_PLACE_PTRS_ctr++;
-#define UPD_OLD_IN_PLACE_NOPTRS() UPD_OLD_IN_PLACE_NOPTRS_ctr++;
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-updates-entered]{Updates Subsequently Entered}
-%* *
-%************************************************************************
-
-If @UPDATES_ENTERED_COUNT@ is defined we add the Age word to the
-closures. This is used to record indicate if a closure has been
-updated but not yet entered. It is set when the closure is updated and
-cleared when subsequently entered.
-
-The commoning up of @CONST@, @CHARLIKE@ and @INTLIKE@ closures is
-turned if this is required. This has only been done for 2s collection.
-It is done using a nasty hack which defines the @_Evacuate@ and
-@_Scavenge@ code for @CONST@, @CHARLIKE@ and @INTLIKE@ info tables to
-be @_Evacuate_1@ and @_Scavenge_1_0@.
-
-Unfortunately this broke everything so it has not been done ;-(.
-Instead we have to run with enough heap so no garbage collection is
-needed for accurate numbers. ToDo: Fix this!
-
-As implemented it can not be used in conjunction with heap profiling
-or lifetime profiling becasue they make conflicting use the Age word!
-
-\begin{code}
-#if defined(UPDATES_ENTERED_COUNT)
-
-#define UPDATED_SET_UPDATED(n) AGE_HDR(n) = 1
-
-#define ENTERED_CHECK_UPDATED(n) \
- if (AGE_HDR(n)) { \
- if (AGE_HDR(n) == 1) { \
- UPD_ENTERED_ctr++; \
- AGE_HDR(n) += 1; \
- } else { \
- UPD_ENTERED_AGAIN_ctr++; \
- AGE_HDR(n) = 0; \
- }}
-
-#else /* ! UPDATES_ENTERED_COUNT */
-
-#define UPDATED_SET_UPDATED(n) /* nothing */
-#define ENTERED_CHECK_UPDATED(n) /* nothing */
-
-#endif /* ! UPDATES_ENTERED_COUNT */
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[ticky-counters]{The accumulators (extern decls)}
-%* *
-%************************************************************************
-
-\begin{code}
-extern I_ ALLOC_HEAP_ctr;
-extern I_ ALLOC_HEAP_tot;
-
-extern PP_ max_SpA;
-extern P_ max_SpB;
-
-extern I_ A_STK_STUB_ctr;
-/* not used at all?
-extern I_ A_STK_REUSE_ctr;
-extern I_ B_STK_REUSE_ctr;
-*/
-
-extern I_ ALLOC_FUN_ctr;
-extern I_ ALLOC_FUN_adm;
-extern I_ ALLOC_FUN_gds;
-extern I_ ALLOC_FUN_slp;
-extern I_ ALLOC_FUN_hst[5];
-extern I_ ALLOC_THK_ctr;
-extern I_ ALLOC_THK_adm;
-extern I_ ALLOC_THK_gds;
-extern I_ ALLOC_THK_slp;
-extern I_ ALLOC_THK_hst[5];
-extern I_ ALLOC_CON_ctr;
-extern I_ ALLOC_CON_adm;
-extern I_ ALLOC_CON_gds;
-extern I_ ALLOC_CON_slp;
-extern I_ ALLOC_CON_hst[5];
-extern I_ ALLOC_TUP_ctr;
-extern I_ ALLOC_TUP_adm;
-extern I_ ALLOC_TUP_gds;
-extern I_ ALLOC_TUP_slp;
-extern I_ ALLOC_TUP_hst[5];
-extern I_ ALLOC_BH_ctr;
-extern I_ ALLOC_BH_adm;
-extern I_ ALLOC_BH_gds;
-extern I_ ALLOC_BH_slp;
-extern I_ ALLOC_BH_hst[5];
-/*
-extern I_ ALLOC_PAP_ctr;
-extern I_ ALLOC_PAP_adm;
-extern I_ ALLOC_PAP_gds;
-extern I_ ALLOC_PAP_slp;
-extern I_ ALLOC_PAP_hst[5];
-*/
-/*
-extern I_ ALLOC_UPD_CON_ctr;
-extern I_ ALLOC_UPD_CON_adm;
-extern I_ ALLOC_UPD_CON_gds;
-extern I_ ALLOC_UPD_CON_slp;
-extern I_ ALLOC_UPD_CON_hst[5];
-*/
-extern I_ ALLOC_UPD_PAP_ctr;
-extern I_ ALLOC_UPD_PAP_adm;
-extern I_ ALLOC_UPD_PAP_gds;
-extern I_ ALLOC_UPD_PAP_slp;
-extern I_ ALLOC_UPD_PAP_hst[5];
-extern I_ ALLOC_PRIM_ctr;
-extern I_ ALLOC_PRIM_adm;
-extern I_ ALLOC_PRIM_gds;
-extern I_ ALLOC_PRIM_slp;
-extern I_ ALLOC_PRIM_hst[5];
-
-#ifdef CONCURRENT
-extern I_ ALLOC_STK_ctr;
-extern I_ ALLOC_STK_adm;
-extern I_ ALLOC_STK_gds;
-extern I_ ALLOC_STK_slp;
-extern I_ ALLOC_STK_hst[5];
-extern I_ ALLOC_TSO_ctr;
-extern I_ ALLOC_TSO_adm;
-extern I_ ALLOC_TSO_gds;
-extern I_ ALLOC_TSO_slp;
-extern I_ ALLOC_TSO_hst[5];
-#ifdef PAR
-extern I_ ALLOC_FMBQ_ctr;
-extern I_ ALLOC_FMBQ_adm;
-extern I_ ALLOC_FMBQ_gds;
-extern I_ ALLOC_FMBQ_slp;
-extern I_ ALLOC_FMBQ_hst[5];
-extern I_ ALLOC_FME_ctr;
-extern I_ ALLOC_FME_adm;
-extern I_ ALLOC_FME_gds;
-extern I_ ALLOC_FME_slp;
-extern I_ ALLOC_FME_hst[5];
-extern I_ ALLOC_BF_ctr;
-extern I_ ALLOC_BF_adm;
-extern I_ ALLOC_BF_gds;
-extern I_ ALLOC_BF_slp;
-extern I_ ALLOC_BF_hst[5];
-#endif
-#endif
-
-extern I_ ENT_VIA_NODE_ctr;
-
-extern I_ ENT_CON_ctr;
-extern I_ ENT_FUN_STD_ctr;
-extern I_ ENT_FUN_DIRECT_ctr;
-extern I_ ENT_IND_ctr;
-extern I_ ENT_PAP_ctr;
-extern I_ ENT_THK_ctr;
-
-extern I_ UPD_ENTERED_ctr;
-extern I_ UPD_ENTERED_AGAIN_ctr;
-
-extern I_ RET_NEW_IN_HEAP_ctr;
-extern I_ RET_NEW_IN_REGS_ctr;
-extern I_ RET_OLD_IN_HEAP_ctr;
-extern I_ RET_OLD_IN_REGS_ctr;
-extern I_ RET_SEMI_BY_DEFAULT_ctr;
-extern I_ RET_SEMI_IN_HEAP_ctr;
-extern I_ RET_SEMI_IN_REGS_ctr;
-extern I_ VEC_RETURN_ctr;
-
-extern I_ ReturnInRegsNodeValid; /* see below */
-
-extern I_ UPDF_OMITTED_ctr;
-extern I_ UPDF_STD_PUSHED_ctr;
-extern I_ UPDF_CON_PUSHED_ctr;
-extern I_ UPDF_HOLE_PUSHED_ctr;
-
-extern I_ UPDF_RCC_PUSHED_ctr;
-extern I_ UPDF_RCC_OMITTED_ctr;
-
-extern I_ UPD_EXISTING_ctr;
-extern I_ UPD_CON_W_NODE_ctr;
-extern I_ UPD_CON_IN_PLACE_ctr;
-extern I_ UPD_PAP_IN_PLACE_ctr;
-extern I_ UPD_CON_IN_NEW_ctr;
-extern I_ UPD_PAP_IN_NEW_ctr;
-
-extern I_ UPD_NEW_IND_ctr;
-extern I_ UPD_NEW_IN_PLACE_PTRS_ctr;
-extern I_ UPD_NEW_IN_PLACE_NOPTRS_ctr;
-extern I_ UPD_OLD_IND_ctr;
-extern I_ UPD_OLD_IN_PLACE_PTRS_ctr;
-extern I_ UPD_OLD_IN_PLACE_NOPTRS_ctr;
-
-extern I_ UPD_IN_PLACE_COPY_ctr; /* see below */
-
-#endif /* DO_REDN_COUNTING */
-\end{code}
-
-%************************************************************************
-%* *
-\subsection[RednCounts-nonmacros]{Un-macros for ``none of the above''}
-%* *
-%************************************************************************
-
-\begin{code}
-#if ! (defined(DO_SPAT_PROFILING) || defined(DO_REDN_COUNTING))
-
-#define SET_ACTIVITY(act) /* nothing */
-
-#define ALLOC_HEAP(n) /* nothing */
-#define UN_ALLOC_HEAP(n) /* nothing */
-#define DO_ASTK_HWM() /* nothing */
-#define DO_BSTK_HWM() /* nothing */
-
-#define A_STK_STUB(n) /* nothing */
-#define A_STK_REUSE(n) /* not used at all */
-#define B_STK_REUSE(n) /* not used at all */
-
-#define ALLOC_FUN(a,g,s,t) /* nothing */
-#define ALLOC_THK(a,g,s,t) /* nothing */
-#define ALLOC_CON(a,g,s,t) /* nothing */
-#define ALLOC_TUP(a,g,s,t) /* nothing */
-#define ALLOC_BH(a,g,s,t) /* nothing */
-/*#define ALLOC_PAP(a,g,s,t) /? nothing */
-#define ALLOC_PRIM(a,g,s,t) /* nothing */
-#define ALLOC_PRIM2(w) /* nothing */
-#define ALLOC_UPD_PAP(a,g,s,t) /* nothing */
-/*#define ALLOC_UPD_CON(a,g,s,t) /? nothing */
-#define ALLOC_STK(a,g,s) /* nothing */
-#define ALLOC_TSO(a,g,s) /* nothing */
-#define ALLOC_FMBQ(a,g,s) /* nothing */
-#define ALLOC_FME(a,g,s) /* nothing */
-#define ALLOC_BF(a,g,s) /* nothing */
-
-#define ENT_VIA_NODE() /* nothing */
-#define ENT_THK() /* nothing */
-#define ENT_FUN_STD() /* nothing */
-#define ENT_FUN_DIRECT(f,f_str,f_arity,Aargs,Bargs,arg_kinds,wrap,wrap_kinds) \
- /* nothing */
-#define ENT_CON(n) /* nothing */
-#define ENT_IND(n) /* nothing */
-#define ENT_PAP(n) /* nothing */
-
-#define RET_NEW_IN_HEAP() /* nothing */
-#define RET_NEW_IN_REGS() /* nothing */
-#define RET_OLD_IN_HEAP() /* nothing */
-#define RET_OLD_IN_REGS() /* nothing */
-#define RET_SEMI_BY_DEFAULT() /* nothing */
-#define RET_SEMI_IN_HEAP() /* nothing */
-#define RET_SEMI_IN_REGS() /* nothing */
-#define VEC_RETURN() /* nothing */
-
-#define UPDF_OMITTED() /* nothing */
-#define UPDF_STD_PUSHED() /* nothing */
-#define UPDF_CON_PUSHED() /* nothing */
-#define UPDF_HOLE_PUSHED() /* nothing */
-
-#define UPDF_RCC_PUSHED() /* nothing */
-#define UPDF_RCC_OMITTED() /* nothing */
-
-#define UPD_EXISTING() /* nothing */
-#define UPD_CON_W_NODE() /* nothing */
-#define UPD_CON_IN_PLACE() /* nothing */
-#define UPD_PAP_IN_PLACE() /* nothing */
-#define UPD_CON_IN_NEW() /* nothing */
-#define UPD_PAP_IN_NEW() /* nothing */
-\end{code}
-
-For special subsequent enter counting:
-\begin{code}
-#define UPDATED_SET_UPDATED(n) /* nothing */
-#define ENTERED_CHECK_UPDATED(n) /* nothing */
-\end{code}
-
-For a generational collector:
-\begin{code}
-#define UPD_NEW_IND() /* nothing */
-#define UPD_NEW_IN_PLACE_PTRS() /* nothing */
-#define UPD_NEW_IN_PLACE_NOPTRS() /* nothing */
-#define UPD_OLD_IND() /* nothing */
-#define UPD_OLD_IN_PLACE_PTRS() /* nothing */
-#define UPD_OLD_IN_PLACE_NOPTRS() /* nothing */
-
-#endif /* <none-of-the-above> */
-\end{code}
-
-End of file multi-slurp protection:
-\begin{code}
-#endif /* ! REDNCOUNTS_H */
-\end{code}
projects / ghc-hetmet.git / blobdiff