2 % (c) The OBFUSCATION-THROUGH-GRATUITOUS-PREPROCESSOR-ABUSE Project,
3 % Glasgow University, 1990-1994
8 % o I think it would be worth making the connection with CPS explicit.
9 % Now that we have explicit activation records (on the stack), we can
10 % explain the whole system in terms of CPS and tail calls --- with the
11 % one requirement that we carefuly distinguish stack-allocated objects
12 % from heap-allocated objects.
15 % \documentstyle[preprint]{acmconf}
16 \documentclass[11pt]{article}
17 \oddsidemargin 0.1 in % Note that \oddsidemargin = \evensidemargin
18 \evensidemargin 0.1 in
19 \marginparwidth 0.85in % Narrow margins require narrower marginal notes
25 \newcommand{\note}[1]{{\em Note: #1}}
35 \setlength{\parskip}{0.15cm}
36 \setlength{\parsep}{0.15cm}
37 \setlength{\topsep}{0cm} % Reduces space before and after verbatim,
38 % which is implemented using trivlist
39 \setlength{\parindent}{0cm}
41 \renewcommand{\textfraction}{0.2}
42 \renewcommand{\floatpagefraction}{0.7}
46 \newcommand{\ToDo}[1]{{{\bf ToDo:}\sl #1}}
47 \newcommand{\Arg}[1]{\mbox{${\tt arg}_{#1}$}}
48 \newcommand{\bottom}{bottom} % foo, can't remember the symbol name
50 \title{The STG runtime system (revised)}
51 \author{Simon Peyton Jones \\ Glasgow University and Oregon Graduate Institute \and
52 Alastair Reid \\ Yale University}
62 This document describes the GHC/Hugs run-time system. It serves as
63 a Glasgow/Yale/Nottingham ``contract'' about what the RTS does.
65 \subsection{New features compared to GHC 2.04}
68 \item The RTS supports mixed compiled/interpreted execution, so
69 that a program can consist of a mixture of GHC-compiled and Hugs-interpreted
72 \item CAFs are only retained if they are
73 reachable. Since they are referred to by implicit references buried
74 in code, this means that the garbage collector must traverse the whole
75 accessible code tree. This feature eliminates a whole class of painful
78 \item A running thread has only one stack, which contains a mixture
79 of pointers and non-pointers. Section~\ref{sect:stacks} describes how
80 we find out which is which. (GHC has used two stacks for some while.
81 Using one stack instead of two reduces register pressure, reduces the
82 size of update frames, and eliminates
83 ``stack-stubbing'' instructions.)
87 \subsection{Wish list}
89 Here's a list of things we'd like to support in the future.
91 \item Interrupts, speculative computation.
94 The SM could tune the size of the allocation arena, the number of
95 generations, etc taking into account residency, GC rate and page fault
99 There should be no need to specify the amnount of stack/heap space to
100 allocate when you started a program - let it just take as much or as
101 little as it wants. (It might be useful to be able to specify maximum
102 sizes and to be able to suggest an initial size.)
105 We could trigger a GC when all threads are blocked waiting for IO if
106 the allocation arena (or some of the generations) are nearly full.
110 \subsection{Configuration}
112 Some of the above features are expensive or less portable, so we
113 envision building a number of different configurations supporting
114 different subsets of the above features.
116 You can make the following choices:
119 Support for concurrency or parallelism. There are four
120 mutually-exclusive choices.
123 \item[@SEQUENTIAL@] No concurrency or parallelism support.
124 This configuration might not support interrupt recovery.
125 \item[@CONCURRENT@] Support for concurrency but not for parallelism.
126 \item[@CONCURRENT@+@GRANSIM@] Concurrency support and simulated parallelism.
127 \item[@CONCURRENT@+@PARALLEL@] Concurrency support and real parallelism.
130 \item @PROFILING@ adds cost-centre profiling.
132 \item @TICKY@ gathers internal statistics (often known as ``ticky-ticky'' code).
134 \item @DEBUG@ does internal consistency checks.
136 \item Persistence. (well, not yet).
139 Which garbage collector to use. At the moment we
140 only anticipate one, however.
143 \subsection{Terminology}
147 \item A {\em word} is (at least) 32 bits and can hold either a signed
150 \item A {\em pointer} is (at least) 32 bits and big enough to hold a
151 function pointer or a data pointer.
153 \item A {\em closure} is a (representation of) a value of a {\em pointed}
154 type. It may be in HNF or it may be unevaluated --- in either case, you can
155 try to evaluate it again.
157 \item A {\em thunk} is a (representation of) a value of a {\em pointed}
158 type which is {\em not} in HNF.
162 Occasionally, a field of a data structure must hold either a word or a
163 pointer. In such circumstances, it is {\em not safe} to assume that
164 words and pointers are the same size.
167 % More terminology to mention.
170 There are a few other system invariants which need to be mentioned ---
171 though not necessarily here:
175 \item The garbage collector never expands an object when it promotes
176 it to the old generation. This is important because the GC avoids
177 performing heap overflow checks by assuming that the amount added to
178 the old generation is no bigger than the current new generation.
182 %-----------------------------------------------------------------------------
183 \part{Evaluation Model}
184 \section{Compiled Execution}
186 This section describes the framework in which compiled code evaluates
187 expressions. Only at certain points will compiled code need to be
188 able to talk to the interpreted world; these are discussed in Section
189 \ref{sect:switching-worlds}.
191 \subsection{Calling conventions}
193 \subsubsection{The call/return registers}
195 One of the problems in designing a virtual machine is that we want it
196 abstract away from tedious machine details but still reveal enough of
197 the underlying hardware that we can make sensible decisions about code
198 generation. A major problem area is the use of registers in
199 call/return conventions. On a machine with lots of registers, it's
200 cheaper to pass arguments and results in registers than to pass them
201 on the stack. On a machine with very few registers, it's cheaper to
202 pass arguments and results on the stack than to use ``virtual
203 registers'' in memory. We therefore use a hybrid system: the first
204 $n$ arguments or results are passed in registers; and the remaining
205 arguments or results are passed on the stack. For register-poor
206 architectures, it is important that we allow $n=0$.
208 We'll label the arguments and results \Arg{1} \ldots \Arg{m} --- with
209 the understanding that \Arg{1} \ldots \Arg{n} are in registers and
210 \Arg{n+1} \ldots \Arg{m} are on top of the stack.
212 Note that the mapping of arguments \Arg{1} \ldots \Arg{n} to machine
213 registers depends on the {\em kinds} of the arguments. For example,
214 if the first argument is a Float, we might pass it in a different
215 register from if it is an Int. In fact, we might find that a given
216 architecture lets us pass varying numbers of arguments according to
217 their types. For example, if a CPU has 2 Int registers and 2 Float
218 registers then we could pass between 2 and 4 arguments in machine
219 registers --- depending on whether they all have the same kind or they
220 have different kinds.
222 \subsubsection{Entering closures}
224 To evaluate a closure we jump to the entry code for the closure
225 passing a pointer to the closure in \Arg{1} so that the entry code can
226 access its environment.
228 \subsubsection{Function call}
230 The function-call mechanism is obviously crucial. There are five different
234 \item {\em Known combinator (function with no free variables) and enough arguments.}
236 A fast call can be made: push excess arguments onto stack and jump to
237 function's {\em fast entry point} passing arguments in \Arg{1} \ldots
240 The {\em fast entry point} is only called with exactly the right
241 number of arguments (in \Arg{1} \ldots \Arg{m}) so it can instantly
242 start doing useful work without first testing whether it has enough
243 registers or having to pop them off the stack first.
245 \item {\em Known combinator and insufficient arguments.}
247 A slow call can be made: push all arguments onto stack and jump to
248 function's {\em slow entry point}.
250 Any unpointed arguments which are pushed on the stack must be tagged.
251 This means pushing an extra word on the stack below the unpointed
252 words, containing the number of unpointed words above it.
254 %Todo: forward ref about tagging?
257 The {\em slow entry point} might be called with insufficient arguments
258 and so it must test whether there are enough arguments on the stack.
259 This {\em argument satisfaction check} consists of checking that
260 @Su-Sp@ is big enough to hold all the arguments (including any tags).
264 \item If the argument satisfaction check fails, it is because there is
265 one or more update frames on the stack before the rest of the
266 arguments that the function needs. In this case, we construct a PAP
267 (partial application, section~\ref{sect:PAP}) containing the arguments
268 which are on the stack. The PAP construction code will return to the
269 update frame with the address of the PAP in \Arg{1}.
271 \item If the argument satisfaction check succeeds, we jump to the fast
272 entry point with the arguments in \Arg{1} \ldots \Arg{arity}.
274 If the fast entry point expects to receive some of \Arg{i} on the
275 stack, we can reduce the amount of movement required by making the
276 stack layout for the fast entry point look like the stack layout for
277 the slow entry point. Since the slow entry point is entered with the
278 first argument on the top of the stack and with tags in front of any
279 unpointed arguments, this means that if \Arg{i} is unpointed, there
280 should be space below it for a tag and that the highest numbered
281 argument should be passed on the top of the stack.
283 We usually arrange that the fast entry point is placed immediately
284 after the slow entry point --- so we can just ``fall through'' to the
285 fast entry point without performing a jump.
290 \item {\em Known function closure (function with free variables) and enough arguments.}
292 A fast call can be made: push excess arguments onto stack and jump to
293 function's {\em fast entry point} passing a pointer to closure in
294 \Arg{1} and arguments in \Arg{2} \ldots \Arg{m+1}.
296 Like the fast entry point for a combinator, the fast entry point for a
297 closure is only called with appropriate values in \Arg{1} \ldots
298 \Arg{m+1} so we can start work straight away. The pointer to the
299 closure is used to access the free variables of the closure.
302 \item {\em Known function closure and insufficient arguments.}
304 A slow call can be made: push all arguments onto stack and jump to the
305 closure's slow entry point passing a pointer to the closure in \Arg{1}.
307 Again, the slow entry point performs an argument satisfaction check
308 and either builds a PAP or pops the arguments off the stack into
309 \Arg{2} \ldots \Arg{m+1} and jumps to the fast entry point.
312 \item {\em Unknown function closure or thunk.}
314 Sometimes, the function being called is not statically identifiable.
315 Consider, for example, the @compose@ function:
317 compose f g x = f (g x)
319 Since @f@ and @g@ are passed as arguments to @compose@, the latter has
320 to make a heap call. In a heap call the arguments are pushed onto the
321 stack, and the closure bound to the function is entered. In the
322 example, a thunk for @(g x)@ will be allocated, (a pointer to it)
323 pushed on the stack, and the closure bound to @f@ will be
324 entered. That is, we will jump to @f@s entry point passing @f@ in
325 \Arg{1}. If \Arg{1} is passed on the stack, it is pushed on top of
326 the thunk for @(g x)@.
328 The {\em entry code} for an updateable thunk (which must have arity 0)
329 pushes an update frame on the stack and starts executing the body of
330 the closure --- using \Arg{1} to access any free variables. This is
331 described in more detail in section~\ref{sect:data-updates}.
333 The {\em entry code} for a non-updateable closure is just the
334 closure's slow entry point.
338 In addition to the above considerations, if there are \emph{too many}
339 arguments then the extra arguments are simply pushed on the stack with
342 To summarise, a closure's standard (slow) entry point performs the following:
344 \item[Argument satisfaction check.] (function closure only)
345 \item[Stack overflow check.]
346 \item[Heap overflow check.]
347 \item[Copy free variables out of closure.] %Todo: why?
348 \item[Eager black holing.] (updateable thunk only) %Todo: forward ref.
349 \item[Push update frame.]
350 \item[Evaluate body of closure.]
354 \subsection{Case expressions and return conventions}
355 \label{sect:return-conventions}
357 The {\em evaluation} of a thunk is always initiated by
358 a @case@ expression. For example:
363 The code for a @case@ expression looks like this:
366 \item Push the free variables of the branches on the stack (fv(@E@) in
368 \item Push a \emph{return address} on the stack.
369 \item Evaluate the scrutinee (@x@ in this case).
372 Once evaluation of the scrutinee is complete, execution resumes at the
373 return address, which points to the code for the expression @E@.
375 When execution resumes at the return point, there must be some {\em
376 return convention} that defines where the components of the pair, @a@
377 and @b@, can be found. The return convention varies according to the
378 type of the scrutinee @x@:
384 (A space for) the return address is left on the top of the stack.
385 Leaving the return address on the stack ensures that the top of the
386 stack contains a valid activation record
387 (section~\ref{sect:activation-records}) --- should a garbage collection
390 \item If @x@ has a pointed type (e.g.~a data constructor or a function),
391 a pointer to @x@ is returned in \Arg{1}.
393 \ToDo{Warn that components of E should be extracted as soon as
394 possible to avoid a space leak.}
396 \item If @x@ is an unpointed type (e.g.~@Int#@ or @Float#@), @x@ is
399 \item If @x@ is an unpointed tuple constructor, the components of @x@
400 are returned in \Arg{1} \ldots \Arg{n} but no object is constructed in
401 the heap. Unboxed tuple constructors are useful for functions which
402 want to return multiple values such as those used in an (explicitly
403 encoded) state monad:
405 \ToDo{Move stuff about unboxed tuples to a separate section}
408 data unpointed AAndState a = AnS a State
409 type S a = State -> AAndState a
411 bindS m k s0 = case m s0 of { AnS s1 a -> k s1 a }
412 returnS a s = AnS a s
415 Note that unboxed datatypes can only have one constructor and that
416 thunks never have unboxed types --- so we'll never try to update an
417 unboxed constructor. Unboxed tuples are \emph{never} built on the
420 When passing an unboxed tuple to a function, the components are
421 flattened out and passed in \Arg{1} \ldots \Arg{n} as usual.
425 \subsection{Vectored Returns}
427 Many algebraic data types have more than one constructor. For
428 example, the @Maybe@ type is defined like this:
430 data Maybe a = Nothing | Just a
432 How does the return convention encode which of the two constructors is
433 being returned? A @case@ expression scrutinising a value of @Maybe@
434 type would look like this:
440 Rather than pushing a return address before evaluating the scrutinee,
441 @E@, the @case@ expression pushes (a pointer to) a {\em return
442 vector}, a static table consisting of two code pointers: one for the
443 @Just@ alternative, and one for the @Nothing@ alternative.
449 The constructor @Nothing@ returns by jumping to the first item in the
450 return vector with a pointer to a (statically built) Nothing closure
453 It might seem that we could avoid loading \Arg{1} in this case since the
454 first item in the return vector will know that @Nothing@ was returned
455 (and can easily access the Nothing closure in the (unlikely) event
456 that it needs it. The only reason we load \Arg{1} is in case we have to
457 perform an update (section~\ref{sect:data-updates}).
461 The constructor @Just@ returns by jumping to the second element of the
462 return vector with a pointer to the closure in \Arg{1}.
466 In this way no test need be made to see which constructor returns;
467 instead, execution resumes immediately in the appropriate branch of
470 \subsection{Direct Returns}
472 When a datatype has a large number of constructors, it may be
473 inappropriate to use vectored returns. The vector tables may be
474 large and sparse, and it may be better to identify the constructor
475 using a test-and-branch sequence on the tag. For this reason, we
476 provide an alternative return convention, called a \emph{direct
479 In a direct return, the return address pushed on the stack really is a
480 code pointer. The returning code loads a pointer to the closure being
481 returned in \Arg{1} as usual, and also loads the tag into \Arg{2}.
482 The code at the return address will test the tag and jump to the
483 appropriate code for the case branch.
485 The choice of whether to use a vectored return or a direct return is
486 made on a type-by-type basis --- up to a certain maximum number of
487 constructors imposed by the update mechanism
488 (section~\ref{sect:data-updates}).
490 Single-constructor data types also use direct returns, although in
491 that case there is no need to return a tag in \Arg{2}.
493 \ToDo{Say whether we pop the return address before returning}
495 \ToDo{Stack stubbing?}
498 \label{sect:data-updates}
500 The entry code for an updatable thunk (which must also be of arity 0):
503 \item copies the free variables out of the thunk into registers or
505 \item pushes an {\em update frame} onto the stack.
507 An update frame is a small activation record consisting of
509 \begin{tabular}{|l|l|l|}
511 {\em Fixed header} & {\em Update Frame link} & {\em Updatee} \\
516 \note{In the semantics part of the STG paper (section 5.6), an update
517 frame consists of everything down to the last update frame on the
518 stack. This would make sense too --- and would fit in nicely with
519 what we're going to do when we add support for speculative
521 \ToDo{I think update frames contain cost centres sometimes}
524 If we are doing ``eager blackholing,'' we then overwrite the thunk
525 with a black hole. Otherwise, we leave it to the garbage collector to
526 black hole the thunk.
529 Start evaluating the body of the expression.
533 When the expression finishes evaluation, it will enter the update
534 frame on the top of the stack. Since the returner doesn't know
535 whether it is entering a normal return address/vector or an update
536 frame, we follow exactly the same conventions as return addresses and
537 return vectors. That is, on entering the update frame:
540 \item The value of the thunk is in \Arg{1}. (Recall that only thunks
541 are updateable and that thunks return just one value.)
543 \item If the data type is a direct-return type rather than a
544 vectored-return type, then the tag is in \Arg{2}.
546 \item The update frame is still on the stack.
549 We can safely share a single statically-compiled update function
550 between all types. However, the code must be able to handle both
551 vectored and direct-return datatypes. This is done by arranging that
552 the update code looks like this:
560 |---------------| <- update code pointer
565 Each entry in the return vector (which is large enough to cover the
566 largest vectored-return type) points to the update code.
570 \item overwrites the {\em updatee} with an indirection to \Arg{1};
571 \item loads @Su@ from the Update Frame link;
572 \item removes the update frame from the stack; and
573 \item enters \Arg{1}.
576 We enter \Arg{1} again, having probably just come from there, because
577 it knows whether to perform a direct or vectored return. This could
578 be optimised by compiling special update code for each slot in the
579 return vector, which performs the correct return.
581 \subsection{Semi-tagging}
582 \label{sect:semi-tagging}
584 When a @case@ expression evaluates a variable that might be bound
585 to a thunk it is often the case that the scrutinee is already evaluated.
586 In this case we have paid the penalty of (a) pushing the return address (or
587 return vector address) on the stack, (b) jumping through the info pointer
588 of the scrutinee, and (c) returning by an indirect jump through the
589 return address on the stack.
591 If we knew that the scrutinee was already evaluated we could generate
592 (better) code which simply jumps to the appropriate branch of the @case@
593 with a pointer to the scrutinee in \Arg{1}.
595 An obvious idea, therefore, is to test dynamically whether the heap
596 closure is a value (using the tag in the info table). If not, we
597 enter the closure as usual; if so, we jump straight to the appropriate
598 alternative. Here, for example, is pseudo-code for the expression
599 @(case x of { (a,_,c) -> E }@:
601 \Arg{1} = <pointer to x>;
602 tag = \Arg{1}->entry->tag;
604 Sp--; \\ insert space for return address
610 <info table for return address goes here>
611 ret: a = \Arg{1}->data1; \\ suck out a and c to avoid space leak
615 and here is the code for the expression @(case x of { [] -> E1; x:xs -> E2 }@:
617 \Arg{1} = <pointer to x>;
618 tag = \Arg{1}->entry->tag;
620 Sp--; \\ insert space for return address
628 retvec: \\ reversed return vector
629 <return info table for case goes here>
631 panic("Direct return into vectored case");
635 ret2: x = \Arg{1}->head;
639 There is an obvious cost in compiled code size (but none in the size
640 of the bytecodes). There is also a cost in execution time if we enter
641 more thunks than data constructors.
643 Both the direct and vectored returns are easily modified to chase chains
644 of indirections too. In the vectored case, this is most easily done by
645 making sure that @IND = TAG_1 - 1@, and adding an extra field to every
646 return vector. In the above example, the indirection code would be
648 ind: \Arg{1} = \Arg{1}->next;
651 where @ind_loop@ is the second line of code.
653 Note that we have to leave space for a return address since the return
654 address expects to find one. If the body of the expression requires a
655 heap check, we will actually have to write the return address before
656 entering the garbage collector.
659 \subsection{Heap and Stack Checks}
661 \note{I reckon these deserve a subsection of their own}
663 Don't move heap pointer before success occurs.
664 Talk about how stack check looks ahead into the branches of case expressions.
666 \subsection{Handling interrupts/signals}
669 May have to keep C stack pointer in register to placate OS?
670 May have to revert black holes - ouch!
673 \section{Interpreted Execution}
675 This section describes how the Hugs interpreter interprets code in the
676 same environment as compiled code executes. Both evaluation models
677 use a common garbage collector, so they must agree on the form of
680 Hugs interprets code by converting it to byte-code and applying a
681 byte-code interpreter to it. Wherever possible, we try to ensure that
682 the byte-code is all that is required to interpret a section of code.
683 This means not dynamically generating info tables, and hence we can
684 only have a small number of possible heap objects each with a staticly
685 compiled info table. Similarly for stack objects: in fact we only
686 have one Hugs stack object, in which all information is tagged for the
689 There is, however, one exception to this rule. Hugs must generate
690 info tables for any constructors it is asked to compile, since the
691 alternative is to force a context-switch each time compiled code
692 enters a Hugs-built constructor, which would be prohibitively
695 \subsection{Hugs Heap Objects}
696 \label{sect:hugs-heap-objects}
698 \subsubsection{Byte-Code Objects}
700 Compiled byte code lives on the global heap, in objects called
701 Byte-Code Objects (or BCOs). The layout of BCOs is described in
702 detail in Section \ref{sect:BCO}, in this section we will describe
705 Since byte-code lives on the heap, it can be garbage collected just
706 like any other heap-resident data. Hugs maintains a table of
707 currently live BCOs, which is treated as a table of live pointers by
708 the garbage collector. When a module is unloaded, the pointers to its
709 BCOs are removed from the table, and the code will be garbage
710 collected some time later.
712 A BCO represents a basic block of code - all entry points are at the
713 beginning of a BCO, and it is impossible to jump into the middle of
714 one. A BCO represents not only the code for a function, but also its
715 closure; a BCO can be entered just like any other closure. Hugs
716 performs lambda-lifting during compilation to byte-code, and each
717 top-level combinator becomes a BCO in the heap.
719 \subsubsection{Thunks}
721 A thunk consists of a code pointer, and values for the free variables
722 of that code. Since Hugs byte-code is lambda-lifted, free variables
723 become arguments and are expected to be on the stack by the called
726 Hugs represents thunks with an AP object. The AP object contains one
727 or more pointers to other heap objects. When it is entered, it pushes
728 an update frame followed by its payload on the stack, and enters the
729 first word (which will be a pointer to a BCO). The layout of AP
730 objects is described in more detail in Section \ref{sect:AP}.
732 \subsubsection{Partial Applications}
734 Partial applications are represented by PAP objects. A PAP object is
735 exactly the same as an AP object, except that it is non-updatable.
736 The layout of PAP objects is described in Section \ref{sect:PAP}.
738 \subsection{Calling conventions}
739 \label{sect:hugs-calling-conventions}
741 The calling convention for any byte-code function is straightforward:
744 \item Push any arguments on the stack.
745 \item Push a pointer to the BCO.
746 \item Begin interpreting the byte code.
749 The @ENTER@ byte-code instruction decides how to enter its argument.
750 The object being entered must be either
757 \item A GHC-built closure, or
758 \item An indirection.
761 If @ENTER@ is applied to a BCO, we just begin interpreting the
762 byte-code contained therein. If the object is an AP, we push an
763 update frame, push the values from the AP on the stack, and enter its
764 associated object. If the object is a PAP, we push its values on the
765 stack and enter the first one. If the object is a constructor, we
766 simply return (see Section \ref{sect:hugs-return-convention}). The
767 fourth case is convered in Section \ref{sect:hugs-to-ghc-closure}. If
768 the object is an indirection, we simply enter the object it points to.
770 \subsection{Return convention}
771 \label{sect:hugs-return-convention}
773 When Hugs pushes a return address, it pushes both a pointer to the BCO
774 to return to, and a pointer to a static code fragment @HUGS_RET@ (this
775 will be described in Section \ref{sect:ghc-to-hugs-return}). The
776 stack layout is shown in Figure \ref{fig:hugs-return-fig}.
780 \input{hugs_ret.pstex_t}
782 \caption{Stack layout for a hugs return address}
783 \label{fig:hugs-return-stack}
788 \input{hugs_ret2.pstex_t}
790 \caption{Stack layout on enterings a hugs return address}
791 \label{fig:hugs-return2}
794 When a Hugs byte-code sequence is returning, it first places the
795 return value on the stack. It then examines the return address (now
796 the second word on the stack):
800 \item If the return address is @HUGS_RET@, rearrange the stack so that
801 it has the returned object followed by the pointer to the BCO at the
802 top, then enter the BCO (Figure \ref{fig:hugsreturn2}).
804 \item If the top of the stack is not @HUGS_RET@, we need to do a world
805 switch as described in Section \ref{sect:hugs-to-ghc-return}.
810 \section{The Scheduler}
812 The Scheduler is the heart of the run-time system. A running program
813 consists of a single running thread, and a list of runnable and
814 blocked threads. The running thread returns to the scheduler when any
815 of the following conditions arises:
818 \item A heap check fails, and a garbage collection is required
819 \item Compiled code needs to switch to interpreted code, and vice
821 \item The thread becomes blocked.
822 \item The thread is preempted.
825 A running system has a global state, consisting of
828 \item @Hp@, the current heap pointer, which points to the next
829 available address in the Heap.
830 \item @HpLim@, the heap limit pointer, which points to the end of the
832 \item The Thread Preemption Flag, which is set whenever the currently
833 running thread should be preempted at the next opportunity.
834 \item A list of runnable threads.
835 \item A list of blocked threads.
838 Each thread is represented by a Thread State Object (TSO), which is
839 described in detail in Section \ref{sect:TSO}.
841 The following is pseudo-code for the inner loop of the scheduler
845 while (threads_exist) {
846 // handle global problems: GC, parallelism, etc
848 if (external_message) service_message();
849 // deal with other urgent stuff
851 pick a runnable thread;
853 switch (thread->whatNext) {
854 case (RunGHC pc): status=runGHC(pc); break;
855 case (RunHugs bc): status=runHugs(bc); break;
857 switch (status) { // handle local problems
858 case (StackOverflow): enlargeStack; break;
859 case (Error e) : error(thread,e); break;
860 case (ExitWith e) : exit(e); break;
861 case (Yield) : break;
863 } while (thread_runnable);
867 Optimisations to avoid excess trampolining from Hugs into itself.
868 How do we invoke GC, ccalls, etc.
869 General ccall (@ccall-GC@) and optimised ccall.
871 \section{Switching Worlds}
873 \label{sect:switching-worlds}
875 Because this is a combined compiled/interpreted system, the
876 interpreter will sometimes encounter compiled code, and vice-versa.
878 All world-switches go via the scheduler, ensuring that the world is in
879 a known state ready to enter either compiled code or the interpreter.
880 When a thread is run from the scheduler, the @whatNext@ field in the
881 TSO (Section \ref{sect:TSO}) is checked to find out how to execute the
885 \item If @whatNext@ is set to @ReturnGHC@, we load up the required
886 registers from the TSO and jump to the address at the top of the user
888 \item If @whatNext@ is set to @EnterGHC@, we load up the required
889 registers from the TSO and enter the closure pointed to by the top
891 \item If @whatNext@ is set to @EnterHugs@, we enter the top thing on
892 the stack, using the interpreter.
895 There are four cases we need to consider:
898 \item A GHC thread enters a Hugs-built closure.
899 \item A GHC thread returns to a Hugs-compiled return address.
900 \item A Hugs thread enters a GHC-built closure.
901 \item A Hugs thread returns to a Hugs-compiled return address.
904 GHC-compiled modules cannot call functions in a Hugs-compiled module
905 directly, because the compiler has no information about arities in the
906 external module. Therefore it must assume any top-level objects are
907 CAFs, and enter their closures.
909 \ToDo{dynamic linking stuff}
910 \ToDo{Hugs-built constructors?}
912 We now examine the various cases one by one and describe how the
913 switch happens in each situation.
915 \subsection{A GHC thread enters a Hugs-built closure}
916 \label{sect:ghc-to-hugs-closure}
918 There are two possibilities: GHC has entered the BCO directly (for a
919 top-level function closure), or it has entered an AP.
921 The code for both objects is the same:
924 \item Push the address of the BCO on the stack.
925 \item Save the current state of the thread in its TSO.
926 \item Return to the scheduler, setting @whatNext@ to @EnterHugs@.
929 \subsection{A GHC thread returns to a Hugs-compiled return address}
930 \label{sect:ghc-to-hugs-return}
932 Hugs return addresses are laid out as in Figure
933 \ref{fig:hugs-return-stack}. If GHC is returning, it will return to
934 the address at the top of the stack, namely @HUGS_RET@. The code at
935 @HUGS_RET@ performs the following:
938 \item pushes \Arg{1} (the return value) on the stack.
939 \item saves the thread state in the TSO
940 \item returns to the scheduler with @whatNext@ set to @EnterHugs@.
943 \noindent When Hugs runs, it will enter the return value, which will
944 return using the correct Hugs convention (Section
945 \ref{sect:hugs-return-convention}) to the return address underneath it
948 \subsection{A Hugs thread enters a GHC-compiled closure}
949 \label{sect:hugs-to-ghc-closure}
951 Hugs can recognise a GHC-built closure as not being one of the
952 following types of object:
960 When Hugs is called on to enter a GHC closure, it executes the
961 following sequence of instructions:
964 \item Push the address of the closure on the stack.
965 \item Save the current state of the thread in the TSO.
966 \item Return to the scheduler, with the @whatNext@ field set to
970 \subsection{A Hugs thread returns to a GHC-compiled return address}
971 \label{sect:hugs-to-ghc-return}
973 When hugs encounters a return address on the stack that is not
974 @HUGS_RET@, it knows that a world-switch is required. At this point
975 the stack contains a pointer to the return value, followed by the GHC
976 return address. The following sequence is then performed:
979 \item save the state of the thread in the TSO.
980 \item return to the scheduler, setting @whatNext@ to @EnterGHC@.
983 The first thing that GHC will do is enter the object on the top of the
984 stack, which is a pointer to the return value. This value will then
985 return itself to the return address using the GHC return convention.
987 \part{Implementation}
988 \section{Heap objects}
989 \label{sect:fixed-header}
991 \ToDo{Fix this picture}
1001 Every {\em heap object}, or {\em closure} is a contiguous block
1002 of memory, consisting of a fixed-format {\em header} followed
1003 by zero or more {\em data words}.
1004 The header consists of
1005 the following fields:
1007 \item A one-word {\em info pointer}, which points to
1008 the object's static {\em info table}.
1009 \item Zero or more {\em admin words} that support
1011 \item Profiling (notably a {\em cost centre} word).
1012 \note{We could possibly omit the cost centre word from some
1013 administrative objects.}
1014 \item Parallelism (e.g. GranSim keeps the object's global address here,
1015 though GUM keeps a separate hash table).
1016 \item Statistics (e.g. a word to track how many times a thunk is entered.).
1018 We add a Ticky word to the fixed-header part of closures. This is
1019 used to record indicate if a closure has been updated but not yet
1020 entered. It is set when the closure is updated and cleared when
1021 subsequently entered.
1023 NB: It is {\em not} an ``entry count'', it is an
1024 ``entries-after-update count.'' The commoning up of @CONST@,
1025 @CHARLIKE@ and @INTLIKE@ closures is turned off(?) if this is
1026 required. This has only been done for 2s collection.
1032 Most of the RTS is completely insensitive to the number of admin words.
1033 The total size of the fixed header is @FIXED_HS@.
1035 Many heap objects contain fields allowing them to be inserted onto lists
1036 during evaluation or during garbage collection. The lists required by
1037 the evaluator and storage manager are as follows.
1040 \item 2 lists of threads: runnable threads and sleeping threads.
1042 \item The {\em static object list} is a list of all statically
1043 allocated objects which might contain pointers into the heap.
1044 (Section~\ref{sect:static-objects}.)
1046 \item The {\em updated thunk list} is a list of all thunks in the old
1047 generation which have been updated with an indirection.
1048 (Section~\ref{sect:IND_OLDGEN}.)
1050 \item The {\em mutables list} is a list of all other objects in the
1051 old generation which might contain pointers into the new generation.
1052 Most of the object on this list are ``mutable.''
1053 (Section~\ref{sect:mutables}.)
1055 \item The {\em Foreign Object list} is a list of all foreign objects
1056 which have not yet been deallocated. (Section~\ref{sect:FOREIGN}.)
1058 \item The {\em Spark pool} is a doubly(?) linked list of Spark objects
1059 maintained by the parallel system. (Section~\ref{sect:SPARK}.)
1061 \item The {\em Blocked Fetch list} (or
1062 lists?). (Section~\ref{sect:BLOCKED_FETCH}.)
1064 \item For each thread, there is a list of all update frames on the
1065 stack. (Section~\ref{sect:data-updates}.)
1070 \ToDo{The links for these fields are usually inserted immediately
1071 after the fixed header except ...}
1073 \subsection{Info Tables}
1075 An {\em info table} is a contiguous block of memory, {\em laid out
1076 backwards}. That is, the first field in the list that follows
1077 occupies the highest memory address, and the successive fields occupy
1078 successive decreasing memory addresses.
1081 \begin{tabular}{|c|}
1082 \hline Parallelism Info
1083 \\ \hline Profile Info
1084 \\ \hline Debug Info
1085 \\ \hline Tag/bytecode pointer
1086 \\ \hline Static reference table
1087 \\ \hline Storage manager layout info
1088 \\ \hline Closure type
1089 \\ \hline entry code \ldots
1093 An info table has the following contents (working backwards in memory
1096 \item The {\em entry code} for the closure.
1097 This code appears literally as the (large) last entry in the
1098 info table, immediately preceded by the rest of the info table.
1099 An {\em info pointer} always points to the first byte of the entry code.
1101 \item A one-word {\em closure type field}, @INFO_TYPE@, identifies what kind
1102 of closure the object is. The various types of closure are described
1103 in Section~\ref{sect:closures}.
1104 In some configurations, some useful properties of
1105 closures (is it a HNF? can it be sparked?)
1106 are represented as high-order bits so they can be tested quickly.
1108 \item A single pointer or word --- the {\em storage manager info field},
1109 @INFO_SM@, contains auxiliary information describing the closure's
1110 precise layout, for the benefit of the garbage collector and the code
1111 that stuffs graph into packets for transmission over the network.
1113 \item A one-pointer {\em Static Reference Table (SRT) pointer}, @INFO_SRT@, points to
1114 a table which enables the garbage collector to identify all accessible
1115 code and CAFs. They are fully described in Section~\ref{sect:srt}.
1117 \item A one-pointer {\em tag/bytecode-pointer} field, @INFO_TAG@ or @INFO_BC@.
1118 For data constructors this field contains the constructor tag, in the
1119 range $0..n-1$ where $n$ is the number of constructors.
1121 For other objects that can be entered this field points to the byte
1122 codes for the object. For the constructor case you can think of the
1123 tag as the name of a a suitable bytecode sequence but it can also be used to
1124 implement semi-tagging (section~\ref{sect:semi-tagging}).
1126 One awkward question (which may not belong here) is ``how does the
1127 bytecode interpreter know whether to do a vectored return?'' The
1128 answer is it examines the @INFO_TYPE@ field of the return address:
1129 @RET_VEC_@$sz$ requires a vectored return and @RET_@$sz$ requires a
1132 \item {\em Profiling info\/}
1134 Closure category records are attached to the info table of the
1135 closure. They are declared with the info table. We put pointers to
1136 these ClCat things in info tables. We need these ClCat things because
1137 they are mutable, whereas info tables are immutable. Hashing will map
1138 similar categories to the same hash value allowing statistics to be
1139 grouped by closure category.
1141 Cost Centres and Closure Categories are hashed to provide indexes
1142 against which arbitrary information can be stored. These indexes are
1143 memoised in the appropriate cost centre or category record and
1144 subsequent hashes avoided by the index routine (it simply returns the
1147 There are different features which can be hashed allowing information
1148 to be stored for different groupings. Cost centres have the cost
1149 centre recorded (using the pointer), module and group. Closure
1150 categories have the closure description and the type
1151 description. Records with the same feature will be hashed to the same
1154 The initialisation routines, @init_index_<feature>@, allocate a hash
1155 table in which the cost centre / category records are stored. The
1156 lower bound for the table size is taken from @max_<feature>_no@. They
1157 return the actual table size used (the next power of 2). Unused
1158 locations in the hash table are indicated by a 0 entry. Successive
1159 @init_index_<feature>@ calls just return the actual table size.
1161 Calls to @index_<feature>@ will insert the cost centre / category
1162 record in the @<feature>@ hash table, if not already inserted. The hash
1163 index is memoised in the record and returned.
1165 CURRENTLY ONLY ONE MEMOISATION SLOT IS AVILABLE IN EACH RECORD SO
1166 HASHING CAN ONLY BE DONE ON ONE FEATURE FOR EACH RECORD. This can be
1167 easily relaxed at the expense of extra memoisation space or continued
1170 The initialisation routines must be called before initialisation of
1171 the stacks and heap as they require to allocate storage. It is also
1172 expected that the caller may want to allocate additional storage in
1173 which to store profiling information based on the return table size
1177 \begin{tabular}{|l|}
1181 \\ \hline Description String
1182 \\ \hline Type String
1188 \item[Hash Index] Memoised copy
1190 Is this category selected (-1 == not memoised, selected? 0 or 1)
1192 One of the following values (defined in CostCentre.lh):
1200 A partial application.
1202 A thunk, or suspension.
1207 \item[@ForeignObj_K@]
1208 A Foreign object (non-Haskell heap resident).
1210 The Stable Pointer table. (There should only be one of these but it
1211 represents a form of weak space leak since it can't shrink to meet
1212 non-demand so it may be worth watching separately? ADR)
1213 \item[@INTERNAL_KIND@]
1214 Something internal to the runtime system.
1218 \item[Description] Source derived string detailing closure description.
1219 \item[Type] Source derived string detailing closure type.
1222 \item {\em Parallelism info\/}
1225 \item {\em Debugging info\/}
1232 \section{Kinds of Heap Object}
1233 \label{sect:closures}
1235 Heap objects can be classified in several ways, but one useful one is
1239 {\em Static closures} occupy fixed, statically-allocated memory
1240 locations, with globally known addresses.
1243 {\em Dynamic closures} are individually allocated in the heap.
1246 {\em Stack closures} are closures allocated within a thread's stack
1247 (which is itself a heap object). Unlike other closures, there are
1248 never any pointers to stack closures. Stack closures are discussed in
1249 Section~\ref{sect:stacks}.
1252 A second useful classification is this:
1255 {\em Executive closures}, such as thunks and data constructors,
1256 participate directly in a program's execution. They can be subdivided into
1257 two kinds of objects according to their type:
1260 {\em Pointed objects}, represent values of a {\em pointed} type
1261 (<.pointed types launchbury.>) --i.e.~a type that includes $\bottom$ such as @Int@ or @Int# -> Int#@.
1263 \item {\em Unpointed objects}, represent values of a {\em unpointed} type --i.e.~a type that does not include $\bottom$ such as @Int#@ or @Array#@.
1265 \item {\em Activation frames}, represent ``continuations''. They are
1266 always stored on the stack and are never pointed to by heap objects or
1267 passed as arguments. \note{It's not clear if this will still be true
1268 once we support speculative evaluation.}
1272 \item {\em Administrative closures}, such as stack objects and thread
1273 state objects, do not represent values in the original program.
1276 Only pointed objects can be entered. All pointed objects share a
1277 common header format: the ``pointed header''; while all unpointed
1278 objects share a common header format: the ``unpointed header''.
1279 \ToDo{Describe the difference and update the diagrams to mention
1280 an appropriate header type.}
1282 This section enumerates all the kinds of heap objects in the system.
1283 Each is identified by a distinct @INFO_TYPE@ tag in its info table.
1285 \ToDo{Check this table very carefully}
1287 \begin{tabular}{|l|l|l|l|l|l|l|l|l|l|l|}
1290 closure kind & HNF & UPD & NS & STA & THU & MUT & UPT & BH & IND & Section \\
1296 @CONSTR@ & 1 & & 1 & & & & & & & \ref{sect:CONSTR} \\
1297 @CONSTR_STATIC@ & 1 & & 1 & 1 & & & & & & \ref{sect:CONSTR} \\
1298 @CONSTR_STATIC_NOCAF@ & 1 & & 1 & 1 & & & & & & \ref{sect:CONSTR} \\
1300 @FUN@ & 1 & & ? & & & & & & & \ref{sect:FUN} \\
1301 @FUN_STATIC@ & 1 & & ? & 1 & & & & & & \ref{sect:FUN} \\
1303 @THUNK@ & 1 & 1 & & & 1 & & & & & \ref{sect:THUNK} \\
1304 @THUNK_STATIC@ & 1 & 1 & & 1 & 1 & & & & & \ref{sect:THUNK} \\
1305 @THUNK_SELECTOR@ & 1 & 1 & 1 & & 1 & & & & & \ref{sect:THUNK_SEL} \\
1307 @PAP@ & 1 & & ? & & & & & & & \ref{sect:PAP} \\
1309 @IND@ & & & 1 & & ? & & & & 1 & \ref{sect:IND} \\
1310 @IND_OLDGEN@ & 1 & & 1 & & ? & & & & 1 & \ref{sect:IND} \\
1311 @IND_PERM@ & & & 1 & & ? & & & & 1 & \ref{sect:IND} \\
1312 @IND_OLDGEN_PERM@ & 1 & & 1 & & ? & & & & 1 & \ref{sect:IND} \\
1313 @IND_STATIC@ & ? & & 1 & 1 & ? & & & & 1 & \ref{sect:IND} \\
1320 @ARR_WORDS@ & 1 & & 1 & & & 1 & 1 & & & \ref{sect:ARR_WORDS1},\ref{sect:ARR_WORDS2} \\
1321 @ARR_PTRS@ & 1 & & 1 & & & 1 & 1 & & & \ref{sect:ARR_PTRS} \\
1322 @MUTVAR@ & 1 & & 1 & & & 1 & 1 & & & \ref{sect:MUTVAR} \\
1323 @MUTARR_PTRS@ & 1 & & 1 & & & 1 & 1 & & & \ref{sect:MUTARR_PTRS} \\
1324 @MUTARR_PTRS_FROZEN@ & 1 & & 1 & & & 1 & 1 & & & \ref{sect:MUTARR_PTRS_FROZEN} \\
1326 @FOREIGN@ & 1 & & 1 & & & & 1 & & & \ref{sect:FOREIGN} \\
1328 @BH@ & ? & 0/1 & 1 & & ? & ? & & 1 & ? & \ref{sect:BH} \\
1329 @MVAR@ & & & & & & & & & & \ref{sect:MVAR} \\
1330 @IVAR@ & & & & & & & & & & \ref{sect:IVAR} \\
1331 @FETCHME@ & & & & & & & & & & \ref{sect:FETCHME} \\
1335 Activation frames do not live (directly) on the heap --- but they have
1336 a similar organisation. The classification bits are all zero in
1339 \begin{tabular}{|l|l|}\hline
1340 closure kind & Section \\ \hline
1341 @RET_SMALL@ & \ref{sect:activation-records} \\
1342 @RET_VEC_SMALL@ & \ref{sect:activation-records} \\
1343 @RET_BIG@ & \ref{sect:activation-records} \\
1344 @RET_VEC_BIG@ & \ref{sect:activation-records} \\
1345 @UPDATE_FRAME@ & \ref{sect:activation-records} \\
1349 There are also a number of administrative objects. The classification bits are
1350 all zero in administrative objects.
1352 \begin{tabular}{|l|l|}\hline
1353 closure kind & Section \\ \hline
1354 @TSO@ & \ref{sect:TSO} \\
1355 @STACK_OBJECT@ & \ref{sect:STACK_OBJECT} \\
1356 @STABLEPTR_TABLE@ & \ref{sect:STABLEPTR_TABLE} \\
1357 @SPARK_OBJECT@ & \ref{sect:SPARK} \\
1358 @BLOCKED_FETCH@ & \ref{sect:BLOCKED_FETCH} \\
1362 \ToDo{I guess the parallel system has something like a stable ptr
1363 table. Is there any opportunity for sharing code/data structures
1367 \subsection{Classification bits}
1369 The top bits of the @INFO_TYPE@ tag tells what sort of animal the
1372 \begin{tabular}{|l|l|l|} \hline
1373 Abbrev & Bit & Interpretation \\ \hline
1374 HNF & 0 & 1 $\Rightarrow$ Head normal form \\
1375 UPD & 4 & 1 $\Rightarrow$ May be updated (inconsistent with being a HNF) \\
1376 NS & 1 & 1 $\Rightarrow$ Don't spark me (Any HNF will have this set to 1)\\
1377 STA & 2 & 1 $\Rightarrow$ This is a static closure \\
1378 THU & 8 & 1 $\Rightarrow$ Is a thunk \\
1379 MUT & 3 & 1 $\Rightarrow$ Has mutable pointer fields \\
1380 UPT & 5 & 1 $\Rightarrow$ Has an unpointed type (eg a primitive array) \\
1381 BH & 6 & 1 $\Rightarrow$ Is a black hole \\
1382 IND & 7 & 1 $\Rightarrow$ Is an indirection \\
1386 Updatable structures (@_UP@) are thunks that may be shared. Primitive
1387 arrays (@_BM@ -- Big Mothers) are structures that are always held
1388 in-memory (basically extensions of a closure). Because there may be
1389 offsets into these arrays, a primitive array cannot be handled as a
1390 FetchMe in the parallel system, but must be shipped in its entirety if
1391 its parent closure is shipped.
1393 The other bits in the info-type field simply give a unique bit-pattern
1394 to identify the closure type.
1398 #define _NF 0x0001 /* Normal form */
1399 #define _NS 0x0002 /* Don't spark */
1400 #define _ST 0x0004 /* Is static */
1401 #define _MU 0x0008 /* Is mutable */
1402 #define _UP 0x0010 /* Is updatable (but not mutable) */
1403 #define _BM 0x0020 /* Is a "primitive" array */
1404 #define _BH 0x0040 /* Is a black hole */
1405 #define _IN 0x0080 /* Is an indirection */
1406 #define _TH 0x0100 /* Is a thunk */
1411 SPEC_N SPEC | _NF | _NS
1413 SPEC_U SPEC | _UP | _TH
1416 GEN_N GEN | _NF | _NS
1418 GEN_U GEN | _UP | _TH
1421 TUPLE _NF | _NS | _BM
1422 DATA _NF | _NS | _BM
1423 MUTUPLE _NF | _NS | _MU | _BM
1424 IMMUTUPLE _NF | _NS | _BM
1436 CAF _NF | _NS | _ST | _IN
1445 STKO_DYNAMIC STKO | _MU
1446 STKO_STATIC STKO | _ST
1448 SPEC_RBH _NS | _MU | _BH
1449 GEN_RBH _NS | _MU | _BH
1458 An indirection either points to HNF (post update); or is result of
1459 overwriting a FetchMe, in which case the thing fetched is either
1460 under evaluation (BH), or by now an HNF. Thus, indirections get NoSpark flag.
1464 \subsection{Hugs Objects}
1466 \subsubsection{Byte-Code Objects}
1469 A Byte-Code Object (BCO) is a container for a a chunk of byte-code,
1470 which can be executed by Hugs. For a top-level function, the BCO also
1471 serves as the closure for the function.
1473 The semantics of BCOs are described in Section
1474 \ref{sect:hugs-heap-objects}. A BCO has the following structure:
1477 \begin{tabular}{|l|l|l|l|l|l|}
1479 \emph{BCO} & \emph{Layout} & \emph{Offset} & \emph{Size} &
1480 \emph{Literals} & \emph{Byte code} \\
1487 \item \emph{BCO} is a pointer to a static code fragment/info table that
1488 returns to the scheduler to invoke Hugs (Section
1489 \ref{sect:ghc-to-hugs-closure}).
1490 \item \emph{Layout} contains the number of pointer literals in the
1491 \emph{Literals} field.
1492 \item \emph{Offset} is the offset to the byte code from the start of
1494 \item \emph{Size} is the number of words of byte code in the object.
1495 \item \emph{Literals} contains any pointer and non-pointer literals used in
1496 the byte-codes (including jump addresses), pointers first.
1497 \item \emph{Byte code} contains \emph{Size} words of non-pointer byte
1501 \subsubsection{AP objects}
1504 Hugs uses a standard object called an AP for thunks and partial
1505 applications. The layout of an AP is
1508 \begin{tabular}{|l|l|l|l|}
1510 \emph{AP} & \emph{BCO} & \emph{Layout} & \emph{Free Variables} \\
1518 \item \emph{AP} is a pointer to a statically-compiled code
1519 fragment/info table that returns to the scheduler to invoke Hugs
1520 (Sections \ref{sect:ghc-to-hugs-closure}, \ref{sect:ghc-to-hugs-return}).
1521 \item \emph{BCO} is a pointer to the BCO for the thunk.
1522 \item \emph{Layout} contains the number of pointers and the size of
1523 the \emph{Free Variables} field.
1524 \item \emph{Free Variables} contains the free variables of the
1525 thunk/partial application/return address, pointers first.
1528 \subsection{Pointed Objects}
1530 All pointed objects can be entered.
1532 \subsubsection{Function closures}\label{sect:FUN}
1534 Function closures represent lambda abstractions. For example,
1535 consider the top-level declaration:
1537 f = \x -> let g = \y -> x+y
1540 Both @f@ and @g@ are represented by function closures. The closure
1541 for @f@ is {\em static} while that for @g@ is {\em dynamic}.
1543 The layout of a function closure is as follows:
1545 \begin{tabular}{|l|l|l|l|}\hline
1546 {\em Fixed header} & {\em Pointers} & {\em Non-pointers} \\ \hline
1549 The data words (pointers and non-pointers) are the free variables of
1550 the function closure.
1551 The number of pointers
1552 and number of non-pointers are stored in the @INFO_SM@ word, in the least significant
1553 and most significant half-word respectively.
1555 There are several different sorts of function closure, distinguished
1556 by their @INFO_TYPE@ field:
1558 \item @FUN@: a vanilla, dynamically allocated on the heap.
1560 \item $@FUN_@p@_@np$: to speed up garbage collection a number of
1561 specialised forms of @FUN@ are provided, for particular $(p,np)$ pairs,
1562 where $p$ is the number of pointers and $np$ the number of non-pointers.
1564 \item @FUN_STATIC@. Top-level, static, function closures (such as
1565 @f@ above) have a different
1566 layout than dynamic ones:
1568 \begin{tabular}{|l|l|l|}\hline
1569 {\em Fixed header} & {\em Static object link} \\ \hline
1572 Static function closurs have no free variables. (However they may refer to other
1573 static closures; these references are recorded in the function closure's SRT.)
1574 They have one field that is not present in dynamic closures, the {\em static object
1575 link} field. This is used by the garbage collector in the same way that to-space
1576 is, to gather closures that have been determined to be live but that have not yet
1578 \note{Static function closures that have no static references, and hence
1579 a null SRT pointer, don't need the static object link field. Is it worth
1580 taking advantage of this? See @CONSTR_STATIC_NOCAF@.}
1583 Each lambda abstraction, $f$, in the STG program has its own private info table.
1584 The following labels are relevant:
1586 \item $f$@_info@ is $f$'s info table.
1587 \item $f$@_entry@ is $f$'s slow entry point (i.e. the entry code of its
1588 info table; so it will label the same byte as $f$@_info@).
1589 \item $f@_fast_@k$ is $f$'s fast entry point. $k$ is the number of arguments
1590 $f$ takes; encoding this number in the fast-entry label occasionally catches some nasty
1591 code-generation errors.
1594 \subsubsection{Data Constructors}\label{sect:CONSTR}
1596 Data-constructor closures represent values constructed with
1597 algebraic data type constructors.
1598 The general layout of data constructors is the same as that for function
1601 \begin{tabular}{|l|l|l|l|}\hline
1602 {\em Fixed header} & {\em Pointers} & {\em Non-pointers} \\ \hline
1606 The SRT pointer in a data constructor's info table is never used --- the
1607 code for a constructor does not make any static references.
1608 \note{Use it for something else?? E.g. tag?}
1610 There are several different sorts of constructor:
1612 \item @CONSTR@: a vanilla, dynamically allocated constructor.
1613 \item @CONSTR_@$p$@_@$np$: just like $@FUN_@p@_@np$.
1614 \item @CONSTR_INTLIKE@.
1615 A dynamically-allocated heap object that looks just like an @Int@. The
1616 garbage collector checks to see if it can common it up with one of a fixed
1617 set of static int-like closures, thus getting it out of the dynamic heap
1620 \item @CONSTR_CHARLIKE@: same deal, but for @Char@.
1622 \item @CONSTR_STATIC@ is similar to @FUN_STATIC@, with the complication that
1623 the layout of the constructor must mimic that of a dynamic constructor,
1624 because a static constructor might be returned to some code that unpacks it.
1625 So its layout is like this:
1627 \begin{tabular}{|l|l|l|l|l|}\hline
1628 {\em Fixed header} & {\em Pointers} & {\em Non-pointers} & {\em Static object link}\\ \hline
1631 The static object link, at the end of the closure, serves the same purpose
1632 as that for @FUN_STATIC@. The pointers in the static constructor can point
1633 only to other static closures.
1635 The static object link occurs last in the closure so that static
1636 constructors can store their data fields in exactly the same place as
1637 dynamic constructors.
1639 \item @CONSTR_STATIC_NOCAF@. A statically allocated data constructor
1640 that guarantees not to point (directly or indirectly) to any CAF
1641 (section~\ref{sect:CAF}). This means it does not need a static object
1642 link field. Since we expect that there might be quite a lot of static
1643 constructors this optimisation makes sense. Furthermore, the @NOCAF@
1644 tag allows the compiler to indicate that no CAFs can be reached
1645 anywhere {\em even indirectly}.
1650 For each data constructor $Con$, two
1651 info tables are generated:
1653 \item $Con$@_info@ labels $Con$'s dynamic info table,
1654 shared by all dynamic instances of the constructor.
1655 \item $Con$@_static@ labels $Con$'s static info table,
1656 shared by all static instances of the constructor.
1659 \subsubsection{Thunks}
1661 \label{sect:THUNK_SEL}
1663 A thunk represents an expression that is not obviously in head normal
1664 form. For example, consider the following top-level definitions:
1666 range = between 1 10
1667 f = \x -> let ys = take x range
1670 Here the right-hand sides of @range@ and @ys@ are both thunks; the former
1671 is static while the latter is dynamic.
1673 The layout of a thunk is the same as that for a function closure,
1674 except that it may have some words of ``slop'' at the end to make sure
1676 at least @MIN_UPD_PAYLOAD@ words in addition to its
1679 \begin{tabular}{|l|l|l|l|l|}\hline
1680 {\em Fixed header} & {\em Pointers} & {\em Non-pointers} & {\em Slop} \\ \hline
1683 The @INFO_SM@ word contains the same information as for function
1684 closures; that is, number of pointers and number of non-pointers (excluding slop).
1686 A thunk differs from a function closure in that it can be updated.
1688 There are several forms of thunk:
1690 \item @THUNK@: a vanilla, dynamically allocated thunk.
1691 The garbage collection code for thunks whose
1692 pointer + non-pointer words is less than @MIN_UPD_PAYLOAD@ differs from
1693 that for function closures and data constructors, because the GC code
1694 has to account for the slop.
1695 \item $@THUNK_@p@_@np$. Similar comments apply.
1696 \item @THUNK_STATIC@. A static thunk is also known as
1697 a {\em constant applicative form}, or {\em CAF}.
1700 \begin{tabular}{|l|l|l|l|l|}\hline
1701 {\em Fixed header} & {\em Pointers} & {\em Non-pointers} & {\em Slop} & {\em Static object link}\\ \hline
1705 \item @THUNK_SELECTOR@ is a (dynamically allocated) thunk
1706 whose entry code performs a simple selection operation from
1707 a data constructor drawn from a single-constructor type. For example,
1710 x = case y of (a,b) -> a
1712 is a selector thunk. A selector thunk is laid out like this:
1714 \begin{tabular}{|l|l|l|l|}\hline
1715 {\em Fixed header} & {\em Selectee pointer} \\ \hline
1718 The @INFO_SM@ word contains the byte offset of the desired word in
1719 the selectee. Note that this is different from all other thunks.
1721 The garbage collector ``peeks'' at the selectee's
1722 tag (in its info table). If it is evaluated, then it goes ahead and do
1723 the selection, and then behaves just as if the selector thunk was an
1724 indirection to the selected field.
1726 evaluated, it treats the selector thunk like any other thunk of that
1727 shape. [Implementation notes.
1728 Copying: only the evacuate routine needs to be special.
1729 Compacting: only the PRStart (marking) routine needs to be special.]
1733 The only label associated with a thunk is its info table:
1735 \item[$f$@_info@] is $f$'s info table.
1739 \subsubsection{Partial applications (PAPs)}\label{sect:PAP}
1741 A partial application (PAP) represents a function applied to too few arguments.
1742 It is only built as a result of updating after an argument-satisfaction
1743 check failure. A PAP has the following shape:
1745 \begin{tabular}{|l|l|l|l|}\hline
1746 {\em Fixed header} & {\em No of arg words} & {\em Function closure} & {\em Arg stack} \\ \hline
1749 The ``arg stack'' is a copy of of the chunk of stack above the update
1750 frame; ``no of arg words'' tells how many words it consists of. The
1751 function closure is (a pointer to) the closure for the function whose
1752 argument-satisfaction check failed.
1754 There is just one standard form of PAP with @INFO_TYPE@ = @PAP@.
1755 There is just one info table too, called @PAP_info@.
1756 Its entry code simply copies the arg stack chunk back on top of the
1757 stack and enters the function closure. (It has to do a stack overflow test first.)
1759 There are no static PAPs.
1761 \subsubsection{Indirections}
1763 \label{sect:IND_OLDGEN}
1765 Indirection closures just point to other closures. They are introduced
1766 when a thunk is updated to point to its value.
1767 The entry code for all indirections simply enters the closure it points to.
1769 There are several forms of indirection:
1771 \item[@IND@] is the vanilla, dynamically-allocated indirection.
1772 It is removed by the garbage collector. It has the following
1775 \begin{tabular}{|l|l|l|}\hline
1776 {\em Fixed header} & {\em Target closure} \\ \hline
1780 \item[@IND_OLDGEN@] is the indirection used to update an old-generation
1781 thunk. Its shape is like this:
1783 \begin{tabular}{|l|l|l|}\hline
1784 {\em Fixed header} & {\em Mutable link field} & {\em Target closure} \\ \hline
1787 It contains a {\em mutable link field} that is used to string together
1788 all old-generation indirections that might have a pointer into
1792 \item[@IND_PERMANENT@ and @IND_OLDGEN_PERMANENT@.]
1793 for lexical profiling, it is necessary to maintain cost centre
1794 information in an indirection, so ``permanent indirections'' are
1795 retained forever. Otherwise they are just like vanilla indirections.
1796 \note{If a permanent indirection points to another permanent
1797 indirection or a @CONST@ closure, it is possible to elide the indirection
1798 since it will have no effect on the profiler.}
1799 \note{Do we still need @IND@ and @IND_OLDGEN@
1800 in the profiling build, or can we just make
1801 do with one pair whose behaviour changes when profiling is built?}
1803 \item[@IND_STATIC@] is used for overwriting CAFs when they have been
1804 evaluated. Static indirections are not removed by the garbage
1805 collector; and are statically allocated outside the heap (and should
1806 stay there). Their static object link field is used just as for
1807 @FUN_STATIC@ closures.
1810 \begin{tabular}{|l|l|l|}
1812 {\em Fixed header} & {\em Target closure} & {\em Static object link} \\
1819 \subsubsection{Activation Records}
1821 Activation records are parts of the stack described by return address
1822 info tables (closures with @INFO_TYPE@ values of @RET_SMALL@,
1823 @RET_VEC_SMALL@, @RET_BIG@ and @RET_VEC_BIG@). They are described in
1824 section~\ref{sect:activation-records}.
1827 \subsubsection{Black holes, MVars and IVars}
1832 Black hole closures are used to overwrite closures currently being
1833 evaluated. They inform the garbage collector that there are no live
1834 roots in the closure, thus removing a potential space leak.
1836 Black holes also become synchronization points in the threaded world.
1837 They contain a pointer to a list of blocked threads to be awakened
1838 when the black hole is updated (or @NULL@ if the list is empty).
1840 \begin{tabular}{|l|l|l|}
1842 {\em Fixed header} & {\em Mutable link} & {\em Blocked thread link} \\
1846 The {\em Blocked thread link} points to the TSO of the first thread
1847 waiting for the value of this thunk. All subsequent TSOs in the list
1848 are linked together using their @TSO_LINK@ field.
1850 When the blocking queue is non-@NULL@, the black hole must be added to
1851 the mutables list since the TSOs on the list may contain pointers into
1852 the new generation. There is no need to clutter up the mutables list
1853 with black holes with empty blocking queues.
1858 \subsubsection{FetchMes}\label{sect:FETCHME}
1860 In the parallel systems, FetchMes are used to represent pointers into
1861 the global heap. When evaluated, the value they point to is read from
1864 \ToDo{Describe layout}
1867 \subsection{Unpointed Objects}
1869 A variable of unpointed type is always bound to a {\em value}, never to a {\em thunk}.
1870 For this reason, unpointed objects cannot be entered.
1872 A {\em value} may be:
1874 \item {\em Boxed}, i.e.~represented indirectly by a pointer to a heap object (e.g.~foreign objects, arrays); or
1875 \item {\em Unboxed}, i.e.~represented directly by a bit-pattern in one or more registers (e.g.~@Int#@ and @Float#@).
1877 All {\em pointed} values are {\em boxed}.
1879 \subsubsection{Immutable Objects}
1880 \label{sect:ARR_WORDS1}
1881 \label{sect:ARR_PTRS}
1884 \item[@ARR_WORDS@] is a variable-sized object consisting solely of
1885 non-pointers. It is used for arrays of all
1886 sorts of things (bytes, words, floats, doubles... it doesn't matter).
1888 \begin{tabular}{|c|c|c|c|}
1890 {\em Fixed Hdr} & {\em No of non-pointers} & {\em Non-pointers\ldots} \\ \hline
1894 \item[@ARR_PTRS@] is an immutable, variable sized array of pointers.
1896 \begin{tabular}{|c|c|c|c|}
1898 {\em Fixed Hdr} & {\em Mutable link} & {\em No of pointers} & {\em Pointers\ldots} \\ \hline
1901 The mutable link is present so that we can easily freeze and thaw an
1902 array (by changing the header and adding/removing the array to the
1907 \subsubsection{Mutable Objects}
1908 \label{sect:mutables}
1909 \label{sect:ARR_WORDS2}
1911 \label{sect:MUTARR_PTRS}
1912 \label{sect:MUTARR_PTRS_FROZEN}
1914 Some of these objects are {\em mutable}; they represent objects which
1915 are explicitly mutated by Haskell code through the @ST@ monad.
1916 They're not used for thunks which are updated precisely once.
1917 Depending on the garbage collector, mutable closures may contain extra
1918 header information which allows a generational collector to implement
1919 the ``write barrier.''
1923 \item[@ARR_WORDS@] is also used to represent {\em mutable} arrays of
1924 bytes, words, floats, doubles, etc. It's possible to use the same
1925 object type because even generational collectors don't need to
1928 \item[@MUTVAR@] is a mutable variable.
1930 \begin{tabular}{|c|c|c|}
1932 {\em Fixed Hdr} & {\em Mutable link} & {\em Pointer} \\ \hline
1936 \item[@MUTARR_PTRS@] is a mutable array of pointers.
1937 Such an array may be {\em frozen}, becoming an @SM_MUTARR_PTRS_FROZEN@, with a
1938 different info-table.
1940 \begin{tabular}{|c|c|c|c|}
1942 {\em Fixed Hdr} & {\em Mutable link} & {\em No of ptrs} & {\em Pointers\ldots} \\ \hline
1946 \item[@MUTARR_PTRS_FROZEN@] is a frozen @MUTARR_PTRS@ closure.
1947 The garbage collector converts @MUTARR_PTRS_FROZEN@ to @ARR_PTRS@ as it removes them from
1953 \subsubsection{Foreign Objects}\label{sect:FOREIGN}
1955 Here's what a ForeignObj looks like:
1958 \begin{tabular}{|l|l|l|l|}
1960 {\em Fixed header} & {\em Data} & {\em Free Routine} & {\em Foreign object link} \\
1965 The @FreeRoutine@ is a reference to the finalisation routine to call
1966 when the @ForeignObj@ becomes garbage. If @freeForeignObject@ is
1967 called on a Foreign Object, the @FreeRoutine@ is set to zero and the
1968 garbage collector will not attempt to call @FreeRoutine@ when the
1969 object becomes garbage.
1971 The Foreign object link is a link to the next foreign object in the
1972 list. This list is traversed at the end of garbage collection: if an
1973 object is about to be deallocated (e.g.~it was not marked or
1974 evacuated), the free routine is called and the object is deleted from
1978 The remaining objects types are all administrative --- none of them may be entered.
1980 \subsection{Thread State Objects (TSOs)}\label{sect:TSO}
1982 In the multi-threaded system, the state of a suspended thread is
1983 packed up into a Thread State Object (TSO) which contains all the
1984 information needed to restart the thread and for the garbage collector
1985 to find all reachable objects. When a thread is running, it may be
1986 ``unpacked'' into machine registers and various other memory locations
1987 to provide faster access.
1989 Single-threaded systems don't really {\em need\/} TSOs --- but they do
1990 need some way to tell the storage manager about live roots so it is
1991 convenient to use a single TSO to store the mutator state even in
1992 single-threaded systems.
1994 Rather than manage TSOs' alloc/dealloc, etc., in some {\em ad hoc}
1995 way, we instead alloc/dealloc/etc them in the heap; then we can use
1996 all the standard garbage-collection/fetching/flushing/etc machinery on
1997 them. So that's why TSOs are ``heap objects,'' albeit very special
2000 \begin{tabular}{|l|l|}
2001 \hline {\em Fixed header}
2002 \\ \hline @TSO_LINK@
2003 \\ \hline @TSO_WHATNEXT@
2004 \\ \hline @TSO_WHATNEXT_INFO@
2005 \\ \hline @TSO_STACK@
2006 \\ \hline {\em Exception Handlers}
2007 \\ \hline {\em Ticky Info}
2008 \\ \hline {\em Profiling Info}
2009 \\ \hline {\em Parallel Info}
2010 \\ \hline {\em GranSim Info}
2014 The contents of a TSO are:
2017 \item A pointer (@TSO_LINK@) used to maintain a list of threads with a similar
2018 state (e.g.~all runable, all sleeping, all blocked on the same black
2019 hole, all blocked on the same MVar, etc.)
2021 \item A word (@TSO_WHATNEXT@) which is in suspended threads to record
2022 how to awaken it. This typically requires a program counter which is stored
2023 in the pointer @TSO_WHATNEXT_INFO@
2025 \item A pointer (@TSO_STACK@) to the top stack block.
2027 \item Optional information for ``Ticky Ticky'' statistics: @TSO_STK_HWM@ is
2028 the maximum number of words allocated to this thread.
2030 \item Optional information for profiling:
2031 @TSO_CCC@ is the current cost centre.
2033 \item Optional information for parallel execution:
2036 \item The types of threads (@TSO_TYPE@):
2038 \item[@T_MAIN@] Must be executed locally.
2039 \item[@T_REQUIRED@] A required thread -- may be exported.
2040 \item[@T_ADVISORY@] An advisory thread -- may be exported.
2041 \item[@T_FAIL@] A failure thread -- may be exported.
2044 \item I've no idea what else
2048 \item Optional information for GranSim execution:
2065 \item clock (gransim light only)
2069 Here are the various queues for GrAnSim-type events.
2080 \subsection{Other weird objects}
2082 \label{sect:BLOCKED_FETCH}
2085 \item[@BlockedFetch@ heap objects (`closures')] (parallel only)
2087 @BlockedFetch@s are inbound fetch messages blocked on local closures.
2088 They arise as entries in a local blocking queue when a fetch has been
2089 received for a local black hole. When awakened, we look at their
2090 contents to figure out where to send a resume.
2092 A @BlockedFetch@ closure has the form:
2094 \begin{tabular}{|l|l|l|l|l|l|}\hline
2095 {\em Fixed header} & link & node & gtid & slot & weight \\ \hline
2099 \item[Spark Closures] (parallel only)
2101 Spark closures are used to link together all closures in the spark pool. When
2102 the current processor is idle, it may choose to speculatively evaluate some of
2103 the closures in the pool. It may also choose to delete sparks from the pool.
2105 \begin{tabular}{|l|l|l|l|l|l|}\hline
2106 {\em Fixed header} & {\em Spark pool link} & {\em Sparked closure} \\ \hline
2114 \subsection{Stack Objects}
2115 \label{sect:STACK_OBJECT}
2118 These are ``stack objects,'' which are used in the threaded world as
2119 the stack for each thread is allocated from the heap in smallish
2120 chunks. (The stack in the sequential world is allocated outside of
2123 Each reduction thread has to have its own stack space. As there may
2124 be many such threads, and as any given one may need quite a big stack,
2125 a naive give-'em-a-big-stack-and-let-'em-run approach will cost a {\em
2128 Our approach is to give a thread a small stack space, and then link
2129 on/off extra ``chunks'' as the need arises. Again, this is a
2130 storage-management problem, and, yet again, we choose to graft the
2131 whole business onto the existing heap-management machinery. So stack
2132 objects will live in the heap, be garbage collected, etc., etc..
2134 A stack object is laid out like this:
2137 \begin{tabular}{|l|}
2141 {\em Link to next stack object (0 for last)}
2143 {\em N, the payload size in words}
2145 {\em @Sp@ (byte offset from head of object)}
2147 {\em @Su@ (byte offset from head of object)}
2149 {\em Payload (N words)}
2154 \ToDo{Are stack objects on the mutable list?}
2156 The stack grows downwards, towards decreasing
2157 addresses. This makes it easier to print out the stack
2158 when debugging, and it means that a return address is
2159 at the lowest address of the chunk of stack it ``knows about''
2160 just like an info pointer on a closure.
2162 The garbage collector needs to be able to find all the
2163 pointers in a stack. How does it do this?
2167 \item Within the stack there are return addresses, pushed
2168 by @case@ expressions. Below a return address (i.e. at higher
2169 memory addresses, since the stack grows downwards) is a chunk
2170 of stack that the return address ``knows about'', namely the
2171 activation record of the currently running function.
2173 \item Below each such activation record is a {\em pending-argument
2174 section}, a chunk of
2175 zero or more words that are the arguments to which the result
2176 of the function should be applied. The return address does not
2178 ``know'' how many pending arguments there are, or their types.
2179 (For example, the function might return a result of type $\alpha$.)
2181 \item Below each pending-argument section is another return address,
2182 and so on. Actually, there might be an update frame instead, but we
2183 can consider update frames as a special case of a return address with
2184 a well-defined activation record.
2186 \ToDo{Doesn't it {\em have} to be an update frame? After all, the arg
2187 satisfaction check is @Su - Sp >= ...@.}
2191 The game plan is this. The garbage collector
2192 walks the stack from the top, traversing pending-argument sections and
2193 activation records alternately. Next we discuss how it finds
2194 the pointers in each of these two stack regions.
2197 \subsubsection{Activation records}\label{sect:activation-records}
2199 An {\em activation record} is a contiguous chunk of stack,
2200 with a return address as its first word, followed by as many
2201 data words as the return address ``knows about''. The return
2202 address is actually a fully-fledged info pointer. It points
2203 to an info table, replete with:
2206 \item entry code (i.e. the code to return to).
2207 \item @INFO_TYPE@ is either @RET_SMALL/RET_VEC_SMALL@ or @RET_BIG/RET_VEC_BIG@, depending
2208 on whether the activation record has more than 32 data words (\note{64 for 8-byte-word architectures}) and on whether
2209 to use a direct or a vectored return.
2210 \item @INFO_SM@ for @RET_SMALL@ is a bitmap telling the layout
2211 of the activation record, one bit per word. The least-significant bit
2212 describes the first data word of the record (adjacent to the fixed
2213 header) and so on. A ``@1@'' indicates a non-pointer, a ``@0@''
2215 a pointer. We don't need to indicate exactly how many words there
2217 because when we get to all zeros we can treat the rest of the
2218 activation record as part of the next pending-argument region.
2220 For @RET_BIG@ the @INFO_SM@ field points to a block of bitmap
2221 words, starting with a word that tells how many words are in
2224 \item @INFO_SRT@ is the Static Reference Table for the return
2225 address (Section~\ref{sect:srt}).
2228 The activation record is a fully fledged closure too.
2229 As well as an info pointer, it has all the other attributes of
2230 a fixed header (Section~\ref{sect:fixed-header}) including a saved cost
2231 centre which is reloaded when the return address is entered.
2233 In other words, all the attributes of closures are needed for
2234 activation records, so it's very convenient to make them look alike.
2237 \subsubsection{Pending arguments}
2239 So that the garbage collector can correctly identify pointers
2240 in pending-argument sections we explicitly tag all non-pointers.
2241 Every non-pointer in a pending-argument section is preceded
2242 (at the next lower memory word) by a one-word byte count that
2243 says how many bytes to skip over (excluding the tag word).
2245 The garbage collector traverses a pending argument section from
2246 the top (i.e. lowest memory address). It looks at each word in turn:
2249 \item If it is less than or equal to a small constant @MAX_STACK_TAG@
2251 it treats it as a tag heralding zero or more words of non-pointers,
2252 so it just skips over them.
2254 \item If it points to the code segment, it must be a return
2255 address, so we have come to the end of the pending-argument section.
2257 \item Otherwise it must be a bona fide heap pointer.
2261 \subsection{The Stable Pointer Table}\label{sect:STABLEPTR_TABLE}
2263 A stable pointer is a name for a Haskell object which can be passed to
2264 the external world. It is ``stable'' in the sense that the name does
2265 not change when the Haskell garbage collector runs---in contrast to
2266 the address of the object which may well change.
2268 A stable pointer is represented by an index into the
2269 @StablePointerTable@. The Haskell garbage collector treats the
2270 @StablePointerTable@ as a source of roots for GC.
2272 In order to provide efficient access to stable pointers and to be able
2273 to cope with any number of stable pointers (eg $0 \ldots 100000$), the
2274 table of stable pointers is an array stored on the heap and can grow
2275 when it overflows. (Since we cannot compact the table by moving
2276 stable pointers about, it seems unlikely that a half-empty table can
2277 be reduced in size---this could be fixed if necessary by using a
2278 hash table of some sort.)
2280 In general a stable pointer table closure looks like this:
2283 \begin{tabular}{|l|l|l|l|l|l|l|l|l|l|l|}
2285 {\em Fixed header} & {\em No of pointers} & {\em Free} & $SP_0$ & \ldots & $SP_{n-1}$
2293 \item[@NPtrs@:] number of (stable) pointers.
2295 \item[@Free@:] the byte offset (from the first byte of the object) of the first free stable pointer.
2297 \item[$SP_i$:] A stable pointer slot. If this entry is in use, it is
2298 an ``unstable'' pointer to a closure. If this entry is not in use, it
2299 is a byte offset of the next free stable pointer slot.
2303 When a stable pointer table is evacuated
2305 \item the free list entries are all set to @NULL@ so that the evacuation
2306 code knows they're not pointers;
2308 \item The stable pointer slots are scanned linearly: non-@NULL@ slots
2309 are evacuated and @NULL@-values are chained together to form a new free list.
2312 There's no need to link the stable pointer table onto the mutable
2313 list because we always treat it as a root.
2317 \section{The Storage Manager}
2319 The generational collector remembers the depth of the last generation
2320 collected and the value of the heap pointer at the end of the last GC.
2321 If the mutator has not moved the heap pointer, that means that the
2322 amount of space recovered is insufficient to satisfy even one request
2323 and it is time to collect an older generation or report a heap overflow.
2325 A deeper collection is also triggered when a minor collection fails to
2326 recover at least @...@ bytes of space.
2328 When can a GC happen?
2331 - During updates (ie during returns)
2332 - When a heap check fails
2333 - When a stack check fails (concurrent system only)
2334 - When a context switch happens (concurrent system only)
2336 When do heap checks occur?
2337 - Immediately after entering a thunk
2338 - Immediately after entering a case alternative
2340 When do stack checks occur?
2341 - We calculate the worst-case stack usage of an entire
2342 thunk so there's no need to put a check inside each alternative.
2343 - Immediately after entering a thunk
2344 We can't make a similar worst-case calculation for heap usage
2345 because the heap isn't used in a stacklike manner so any
2346 evaluation inside a case might steal some of the heap we've
2350 - Threads can be blocked
2351 - Threads can be put to sleep
2352 - Heap may move while we sleep
2353 - Black holing may happen while we sleep (ie during GC)
2356 \subsection{The SM state}
2358 Contains @Hp@, @HpLim@, @StablePtrTable@ plus version-specific info.
2362 \item Static Object list
2363 \item Foreign Object list
2364 \item Stable Pointer Table
2368 In addition, the generational collector requires:
2372 \item Old Generation Indirection list
2373 \item Mutables list --- list of mutable objects in the old generation.
2374 \item @OldLim@ --- the boundary between the generations
2375 \item Old Foreign Object list --- foreign objects in the old generation
2379 It is passed a table of {\em roots\/} containing
2383 \item All runnable TSOs
2388 In the parallel system, there must be some extra magic associated with
2391 \subsection{The SM interface}
2393 @initSM@ finalizes any runtime parameters of the storage manager.
2395 @exitSM@ does any cleaning up required by the storage manager before
2396 the program is executed. Its main purpose is to print any summary
2399 @initHeap@ allocates the heap. It initialises the @hp@ and @hplim@
2400 fields of @sm@ to represent an empty heap for the compiled-in garbage
2401 collector. It also initialises @CAFlist@ to be the empty list. If we
2402 are using Appel's collector it also initialises the @OldLim@ field.
2403 It also initialises the stable pointer table and the @ForeignObjList@
2404 (and @OldForeignObjList@) fields.
2406 @collectHeap@ invokes the garbage collector. @collectHeap@ requires
2407 all the fields of @sm@ to be initialised appropriately (from the
2408 STG-machine registers). The following are identified as heap roots:
2410 \item The updated CAFs recorded in @CAFlist@.
2411 \item Any pointers found on the stack.
2412 \item All runnable and sleeping TSOs.
2413 \item The stable pointer table.
2416 There are two possible results from a garbage collection:
2419 The garbage collector is unable to free up any more space.
2422 The garbage collector managed to free up more space.
2425 \item @hp@ and @hplim@ will indicate the new space available for
2428 \item The elements of @CAFlist@ and the stable pointers will be
2429 updated to point to the new locations of the closures they reference.
2431 \item Any members of @ForeignObjList@ which became garbage should have
2432 been reported (by calling their finalising routines; and the
2433 @(Old)ForeignObjList@ updated to contain only those Foreign objects
2434 which are still live.
2441 %************************************************************************
2443 \subsection{``What really happens in a garbage collection?''}
2445 %************************************************************************
2447 This is a brief tutorial on ``what really happens'' going to/from the
2448 storage manager in a garbage collection.
2451 %------------------------------------------------------------------------
2452 \item[The heap check:]
2456 If you gaze into the C output of GHC, you see many macros calls like:
2458 HEAP_CHK_2PtrsLive((_FHS+2));
2461 This expands into the C (roughly speaking...):
2463 Hp = Hp + (_FHS+2); /* optimistically move heap pointer forward */
2465 GC_WHILE_OR_IF (HEAP_OVERFLOW_OP(Hp, HpLim) OR_INTERVAL_EXPIRED) {
2466 STGCALL2_GC(PerformGC, <liveness-bits>, (_FHS+2));
2470 In the parallel world, where we will need to re-try the heap check,
2471 @GC_WHILE_OR_IF@ will be a ``while''; in the sequential world, it will
2474 The ``heap lookahead'' checks, which are similar and used for
2475 multi-precision @Integer@ ops, have some further complications. See
2476 the commentary there (@StgMacros.lh@).
2478 %------------------------------------------------------------------------
2479 \item[Into @callWrapper_GC@...:]
2481 When we failed the heap check (above), we were inside the
2482 GCC-registerised ``threaded world.'' @callWrapper_GC@ is all about
2483 getting in and out of the threaded world. On SPARCs, with register
2484 windows, the name of the game is not shifting windows until we have
2485 what we want out of the old one. In tricky cases like this, it's best
2486 written in assembly language.
2488 Performing a GC (potentially) means giving up the thread of control.
2489 So we must fill in the thread-state-object (TSO) [and its associated
2490 stk object] with enough information for later resumption:
2493 Save the return address in the TSO's PC field.
2495 Save the machine registers used in the STG threaded world in their
2496 corresponding TSO fields. We also save the pointer-liveness
2497 information in the TSO.
2499 The registers that are not thread-specific, notably @Hp@ and
2500 @HpLim@, are saved in the @StorageMgrInfo@ structure.
2502 Call the routine it was asked to call; in this example, call
2503 @PerformGC@ with arguments @<liveness>@ and @_FHS+2@ (some constant)...
2507 %------------------------------------------------------------------------
2508 \item[Into the heap overflow wrapper, @PerformGC@ [parallel]:]
2510 Most information has already been saved in the TSO.
2514 The first argument (@<liveness>@, in our example) say what registers
2515 are live, i.e., are ``roots'' the storage manager needs to know.
2517 StorageMgrInfo.rootno = 2;
2518 StorageMgrInfo.roots[0] = (P_) Ret1_SAVE;
2519 StorageMgrInfo.roots[1] = (P_) Ret2_SAVE;
2523 We move the heap-pointer back [we had optimistically
2524 advanced it, in the initial heap check]
2527 We load up the @smInfo@ data from the STG registers' @*_SAVE@ locations.
2530 We mark on the scheduler's big ``blackboard'' that a GC is
2534 We reschedule, i.e., this thread gives up control. (The scheduler
2535 will presumably initiate a garbage-collection, but it may have to do
2536 any number of other things---flushing, for example---before ``normal
2537 execution'' resumes; and it most certainly may not be this thread that
2538 resumes at that point!)
2541 IT IS AT THIS POINT THAT THE WORLD IS COMPLETELY TIDY.
2543 %------------------------------------------------------------------------
2544 \item[Out of @callWrapper_GC@ [parallel]:]
2546 When this thread is finally resumed after GC (and who knows what
2547 else), it will restart by the normal enter-TSO/enter-stack-object
2548 sequence, which has the effect of re-loading the registers, etc.,
2549 (i.e., restoring the state).
2551 Because the address we saved in the TSO's PC field was that at the end
2552 of the heap check, and because the check is a while-loop in the
2553 parallel system, we will now loop back around, and make sure there is
2554 enough space before continuing.
2559 \subsection{Static Reference Tables (SRTs)}
2562 \label{sect:static-objects}
2564 In the above, we assumed that objects always contained pointers to all
2565 their free variables. In fact, this isn't quite true: GHC omits
2566 pointers to top-level objects and allocates their closures in static
2567 memory. This optimisation reduces the number of free variables in
2568 heap objects - reducing memory usage and the effort needed to put them
2569 into heap objects. However, this optimisation comes at a cost: we
2570 need to complicate the garbage collector with machinery for tracing
2571 these static references.
2573 Early versions of GHC used a very simple algorithm: it treated all
2574 static objects as roots. This is safe in the sense that no object is
2575 ever deallocated if there's a chance that it might be required later
2576 but can lead to some terrible space leaks. For example, this program
2577 ought to be able to run in constant space but, because @xs@ is never
2578 deallocated, it runs in linear space.
2585 The correct behaviour is for the garbage collector to keep a static
2586 object alive iff it might be required later in execution. That is, if
2587 it is reachable from any live heap objects {\em or\/} from any return
2588 addresses found on the stack or from the current program counter.
2589 Since it is obviously infeasible for the garbage collector to scan
2590 machine code looking for static references, the code generator must
2591 generate a table of all static references in any piece of code (and we
2592 must place a pointer to this table next to any piece of code we
2595 Here's what the SRT has to contain:
2601 Here's how we represent it:
2605 must be able to handle 0 references well
2612 o Generational GC trickery
2615 \subsection{Space leaks and black holes}
2616 \label{sect:black-hole}
2620 \ToDo{Insert text stolen from update paper}
2624 A program exhibits a {\em space leak} if it retains storage that is
2625 sure not to be used again. Space leaks are becoming increasingly
2626 common in imperative programs that @malloc@ storage and fail
2627 subsequently to @free@ it. They are, however, also common in
2628 garbage-collected systems, especially where lazy evaluation is
2629 used.[.wadler leak, runciman heap profiling jfp.]
2631 Quite a bit of experience has now accumulated suggesting that
2632 implementors must be very conscientious about avoiding gratuitous
2633 space leaks --- that is, ones which are an accidental artefact of some
2634 implementation technique.[.appel book.] The update mechanism is
2635 a case in point, as <.jones jfp leak.> points out. Consider a thunk for
2638 let xs = [1..1000] in last xs
2640 where @last@ is a function that returns the last element of its
2641 argument list. When the thunk is entered it will call @last@, which
2642 will consume @xs@ until it finds the last element. Since the list
2643 @[1..1000]@ is produced lazily one might reasonably expect the
2644 expression to evaluate in constant space. But {\em until the moment
2645 of update, the thunk itself still retains a pointer to the beginning
2646 of the list @xs@}. So, until the update takes place the whole list
2649 Of course, this is completely gratuitous. The pointer to @xs@ in the
2650 thunk will never be used again. In <.peyton stock hardware.> the solution to
2651 this problem that we advocated was to overwrite a thunk's info with a
2652 fixed ``black hole'' info pointer, {\em at the moment of entry}. The
2653 storage management information attached to a black-hole info pointer
2654 tells the garbage collector that the closure contains no pointers,
2655 thereby plugging the space leak.
2657 \subsubsection{Lazy black-holing}
2659 Black-holing is a well-known idea. The trouble is that it is
2660 gallingly expensive. To avoid the occasional space leak, for every
2661 single thunk entry we have to load a full-word literal constant into a
2662 register (often two instructions) and then store that register into a
2665 Fortunately, this cost can easily be avoided. The
2666 idea is simple: {\em instead of black-holing every thunk on entry,
2667 wait until the garbage collector is called, and then black-hole all
2668 (and only) the thunks whose evaluation is in progress at that moment}.
2669 There is no benefit in black-holing a thunk that is updated before
2670 garbage collection strikes! In effect, the idea is to perform the
2671 black-holing operation lazily, only when it is needed. This
2672 dramatically cuts down the number of black-holing operations, as our
2673 results show {\em forward ref}.
2675 How can we find all the thunks whose evaluation is in progress? They
2676 are precisely the ones for which update frames are on the stack. So
2677 all we need do is find all the update frames (via the @Su@ chain) and
2678 black-hole their thunks right at the start of garbage collection.
2679 Notice that it is not enough to refrain from treating update frames as
2680 roots: firstly because the thunks to which they point may need to be
2681 moved in a copying collector, but more importantly because the thunk
2682 might be accessible via some other route.
2684 \subsubsection{Detecting loops}
2686 Black-holing has a second minor advantage: evaluation of a thunk whose
2687 value depends on itself will cause a black hole closure to be entered,
2688 which can cause a suitable error message to be displayed. For example,
2689 consider the definition
2693 The code to evaluate @x@'s right hand side will evaluate @x@. In the
2694 absence of black-holing, the result will be a stack overflow, as the
2695 evaluator repeatedly pushes a return address and enters @x@. If
2696 thunks are black-holed on entry, then this infinite loop can be caught
2699 With our new method of lazy black-holing, a self-referential program
2700 might cause either stack overflow or a black-hole error message,
2701 depending on exactly when garbage collection strikes. It is quite
2702 easy to conceal these differences, however. If stack overflow occurs,
2703 all we need do is examine the update frames on the stack to see if
2704 more than one refers to the same thunk. If so, there is a loop that
2705 would have been detected by eager black-holing.
2707 \subsubsection{Lazy locking}
2710 In a parallel implementation, it is necessary somehow to ``lock'' a
2711 thunk that is under evaluation, so that other parallel evaluators
2712 cannot simultaneously evaluate it and thereby duplicate work.
2713 Instead, an evaluator that enters a locked thunk should be blocked,
2714 and made runnable again when the thunk is updated.
2716 This locking is readily arranged in the same way as black-holing, by
2717 overwriting the thunk's info pointer with a special ``locked'' info
2718 pointer, at the moment of entry. If another evaluator enters the
2719 thunk before it has been updated, it will land in the entry code for
2720 the ``locked'' info pointer, which blocks the evaluator and queues it
2721 on the locked thunk.
2723 The details are given by <.portable parallel trinder.>. However, the close similarity
2724 between locking and black holing suggests the following question: can
2725 locking be done lazily too? The answer is that it can, except that
2726 locking can be postponed only until the next {\em context switch},
2727 rather than the next {\em garbage collection}. We are assuming here
2728 that the parallel implementation does not use shared memory to allow
2729 two processors to access the same closure. If such access is
2730 permitted then every thunk entry requires a hardware lock, and becomes
2733 Is lazy locking worth while, given that it requires extra work every
2734 context switch? We believe it is, because contexts switches are
2735 relatively infrequent, and thousands of thunk-entries typically take
2738 {\em Measurements elsewhere. Omit this section? If so, fix cross refs to here.}
2743 \subsection{Squeezing identical updates}
2747 \ToDo{Insert text stolen from update paper}
2751 Consider the following Haskell definition of the standard
2752 function @partition@ that divides a list into two, those elements
2753 that satisfy a predicate @p@ and those that do not:
2755 partition :: (a->Bool) -> [a] -> ([a],[a])
2756 partition p [] = ([],[])
2757 partition p (x:xs) = if p x then (x:ys, zs)
2760 (ys,zs) = partition p xs
2762 By the time this definition has been desugared, it looks like this:
2772 if p x then (x:ys,zs)
2775 Lazy evaluation demands that the recursive call is bound to an
2776 intermediate variable, @t@, from which @ys@ and @zs@ are lazily
2777 selected. (The functions @fst@ and @snd@ select the first and second
2778 elements of a pair, respectively.)
2780 Now, suppose that @partition@ is applied to a list @[x1,x2]@,
2782 elements satisfy @p@. We can get a good idea of what will happen
2783 at runtime by unrolling the recursion a few times in our heads.
2784 Unrolling once, and remembering that @(p x1)@ is @True@, we get this:
2788 let t1 = partition [x2]
2793 Unrolling the rest of the way gives this:
2805 Now consider what happens if @zs1@ is evaluated. It is bound to a
2806 thunk, which will push an update frame before evaluating the
2807 expression @snd t1@. This expression in turn forces evaluation of
2808 @zs2@, which pushes an update frame before evaluating @snd t2@.
2809 Indeed the stack of update frames will grow as deep as the list is
2810 long when @zs1@ is evaluated. This is rather galling, since all the
2811 thunks @zs1@, @zs2@, and so on, have the same value.
2813 \ToDo{Describe the state-transformer case in which we get a space leak from
2814 pending update frames.}
2816 The solution is simple. The garbage collector, which is going to traverse the
2817 update stack in any case, can easily identify two update frames that are directly
2818 on top of each other. The second of these will update its target with the same
2819 value as the first. Therefore, the garbage collector can perform the update
2820 right away, by overwriting one update target with an indirection to the second,
2821 and eliminate the corresponding update frame. In this way ever-growing stacks of
2822 update frames are reduced to a single representative at garbage collection time.
2823 If this is done at the start of garbage collection then, if it turns out that
2824 some of these update targets are garbage they will be collected right away.
2828 \subsection{Space leaks and selectors}
2832 \ToDo{Insert text stolen from update paper}
2836 In 1987, Wadler identified an important source of space leaks in
2837 lazy functional programs. Consider the Haskell function definition:
2839 f p = (g1 a, g2 b) where (a,b) = p
2841 The pattern-matching in the @where@ clause is known as
2842 {\em lazy pattern-matching}, because it is performed only if @a@
2843 or @b@ is actually evaluated. The desugarer translates lazy pattern matching
2844 to the use of selectors, @fst@ and @snd@ in this case:
2851 Now suppose that the second component of the pair @(f p)@, namely @a@,
2852 is evaluated and discarded, but the first is not although it remains
2853 reachable. The garbage collector will find that the thunk for @b@ refers
2854 to @p@ and hence to @a@. Thus, although @a@ cannot ever be used again, its
2855 space is retained. It turns out that this space leak can have a very bad effect
2856 indeed on a program's space behaviour (Section~\ref{sect:selector-results}).
2858 Wadler's paper also proposed a solution: if the garbage collector
2859 encounters a thunk of the form @snd p@, where @p@ is evaluated, then
2860 the garbage collector should perform the selection and overwrite the
2861 thunk with a pointer to the second component of the pair. In effect, the
2862 garbage collector thereby performs a bounded amount of as-yet-undemanded evaluation
2863 in the hope of improving space behaviour.
2864 We implement this idea directly, by making the garbage collector
2865 eagerly execute all selector thunks\footnote{A word of caution: it is rather easy
2866 to make a mistake in the implementation, especially if the garbage collector
2867 uses pointer reversal to traverse the reachable graph.},
2869 reported in Section~\ref{sect:THUNK_SEL}.
2871 One could easily imagine generalisations of this idea, with the garbage
2872 collector performing bounded amounts of space-saving work. One example is
2876 f x (y:ys) = f (x+1) ys
2878 Most lazy evaluators will build up a chain of thunks for the accumulating
2879 parameter, @x@, each of which increments @x@. It is not safe to evaluate
2880 any of these thunks eagerly, since @f@ is not strict in @x@, and we know nothing
2881 about the value of @x@ passed in the initial call to @f@.
2882 On the other hand, if the garbage collector found a thunk @(x+1)@ where
2883 @x@ happened to be evaluated, then it could ``execute'' it eagerly.
2884 If done carefully, the entire chain could be eliminated in a single
2885 garbage collection. We have not (yet) implemented this idea.
2886 A very similar idea, dubbed ``stingy evaluation'', is described
2889 <.sparud lazy pattern matching.> describes another solution to the
2890 lazy-pattern-matching
2891 problem. His solution involves adding code to the two thunks for
2892 @a@ and @b@ so that if either is evaluated it arranges to update the
2893 other as well as itself. The garbage-collector solution is a little
2894 more general, since it applies whether or not the selectors were
2895 generated by lazy pattern matching, and in our setting it was easier
2896 to implement than Sparud's.
2901 \subsection{Internal workings of the Compacting Collector}
2903 \subsection{Internal workings of the Copying Collector}
2905 \subsection{Internal workings of the Generational Collector}
2908 \section{Dynamic Linking}
2912 Registering costs centres looks awkward - can we tidy it up?
2914 \section{Parallelism}
2916 Something about global GC, inter-process messages and fetchmes.
2920 \section{Ticky Ticky profiling}
2922 Measure what proportion of ...:
2925 ... Enters are to data values, function values, thunks.
2927 ... allocations are for data values, functions values, thunks.
2929 ... updates are for data values, function values.
2933 ... return-in-heap (dynamic)
2935 ... vectored return (dynamic)
2937 ... updates are wasted (never re-entered).
2939 ... constructor returns get away without hitting an update.
2942 %************************************************************************
2944 \subsubsection[ticky-stk-heap-use]{Stack and heap usage}
2946 %************************************************************************
2948 Things we are interested in here:
2951 How many times we do a heap check and move @Hp@; comparing this with
2952 the allocations gives an indication of how many things we get per trip
2955 If we do a ``heap lookahead,'' we haven't really allocated any
2956 heap, so we need to undo the effects of an @ALLOC_HEAP@:
2959 The stack high-water mark.
2962 Re-use of stack slots, and stubbing of stack slots:
2966 %************************************************************************
2968 \subsubsection[ticky-allocs]{Allocations}
2970 %************************************************************************
2972 We count things every time we allocate something in the dynamic heap.
2973 For each, we count the number of words of (1)~``admin'' (header),
2974 (2)~good stuff (useful pointers and data), and (3)~``slop'' (extra
2975 space, in hopes it will allow an in-place update).
2977 The first five macros are inserted when the compiler generates code
2978 to allocate something; the categories correspond to the @ClosureClass@
2979 datatype (manifest functions, thunks, constructors, big tuples, and
2980 partial applications).
2982 We may also allocate space when we do an update, and there isn't
2983 enough space. These macros suffice (for: updating with a partial
2984 application and a constructor):
2986 In the threaded world, we allocate space for the spark pool, stack objects,
2987 and thread state objects.
2989 The histogrammy bit is fairly straightforward; the @-2@ is: one for
2990 0-origin C arrays; the other one because we do {\em no} one-word
2991 allocations, so we would never inc that histogram slot; so we shift
2992 everything over by one.
2994 Some hard-to-account-for words are allocated by/for primitives,
2995 includes Integer support. @ALLOC_PRIM2@ tells us about these. We
2996 count everything as ``goods'', which is not strictly correct.
2997 (@ALLOC_PRIM@ is the same sort of stuff, but we know the
2998 admin/goods/slop breakdown.)
3000 %************************************************************************
3002 \subsubsection[ticky-enters]{Enters}
3004 %************************************************************************
3006 We do more magical things with @ENT_FUN_DIRECT@. Besides simply knowing
3007 how many ``fast-entry-point'' enters there were, we'd like {\em simple}
3008 information about where those enters were, and the properties thereof.
3010 struct ent_counter {
3011 unsigned registeredp:16, /* 0 == no, 1 == yes */
3012 arity:16, /* arity (static info) */
3013 Astk_args:16, /* # of args off A stack */
3014 Bstk_args:16; /* # of args off B stack */
3015 /* (rest of args are in registers) */
3016 StgChar *f_str; /* name of the thing */
3017 StgChar *f_arg_kinds; /* info about the args types */
3018 StgChar *wrap_str; /* name of its wrapper (if any) */
3019 StgChar *wrap_arg_kinds;/* info about the orig wrapper's arg types */
3020 I_ ctr; /* the actual counter */
3021 struct ent_counter *link; /* link to chain them all together */
3025 %************************************************************************
3027 \subsubsection[ticky-returns]{Returns}
3029 %************************************************************************
3031 Whenever a ``return'' occurs, it is returning the constituent parts of
3032 a data constructor. The parts can be returned either in registers, or
3033 by allocating some heap to put it in (the @ALLOC_*@ macros account for
3034 the allocation). The constructor can either be an existing one
3035 (@*OLD*@) or we could have {\em just} figured out this stuff
3038 Here's some special magic that Simon wants [edited to match names
3042 From: Simon L Peyton Jones <simonpj>
3043 To: partain, simonpj
3044 Subject: counting updates
3045 Date: Wed, 25 Mar 92 08:39:48 +0000
3047 I'd like to count how many times we update in place when actually Node
3048 points to the thing. Here's how:
3050 @RET_OLD_IN_REGS@ sets the variable @ReturnInRegsNodeValid@ to @True@;
3051 @RET_NEW_IN_REGS@ sets it to @False@.
3053 @RET_SEMI_???@ sets it to??? ToDo [WDP]
3055 @UPD_CON_IN_PLACE@ tests the variable, and increments @UPD_IN_PLACE_COPY_ctr@
3058 Then we need to report it along with the update-in-place info.
3062 Of all the returns (sum of four categories above), how many were
3063 vectored? (The rest were obviously unvectored).
3065 %************************************************************************
3067 \subsubsection[ticky-update-frames]{Update frames}
3069 %************************************************************************
3071 These macros count up the following update information.
3073 \begin{tabular}{|l|l|} \hline
3074 Macro & Counts \\ \hline
3076 @UPDF_STD_PUSHED@ & Update frame pushed \\
3077 @UPDF_CON_PUSHED@ & Constructor update frame pushed \\
3078 @UPDF_HOLE_PUSHED@ & An update frame to update a black hole \\
3079 @UPDF_OMITTED@ & A thunk decided not to push an update frame \\
3080 & (all subsets of @ENT_THK@) \\
3081 @UPDF_RCC_PUSHED@ & Cost Centre restore frame pushed \\
3082 @UPDF_RCC_OMITTED@ & Cost Centres not required -- not pushed \\\hline
3085 %************************************************************************
3087 \subsubsection[ticky-updates]{Updates}
3089 %************************************************************************
3091 These macros record information when we do an update. We always
3092 update either with a data constructor (CON) or a partial application
3095 \begin{tabular}{|l|l|}\hline
3096 Macro & Where \\ \hline
3098 @UPD_EXISTING@ & Updating with an indirection to something \\
3099 & already in the heap \\
3100 @UPD_SQUEEZED@ & Same as @UPD_EXISTING@ but because \\
3101 & of stack-squeezing \\
3102 @UPD_CON_W_NODE@ & Updating with a CON: by indirecting to Node \\
3103 @UPD_CON_IN_PLACE@ & Ditto, but in place \\
3104 @UPD_CON_IN_NEW@ & Ditto, but allocating the object \\
3105 @UPD_PAP_IN_PLACE@ & Same, but updating w/ a PAP \\
3106 @UPD_PAP_IN_NEW@ & \\\hline
3109 %************************************************************************
3111 \subsubsection[ticky-selectors]{Doing selectors at GC time}
3113 %************************************************************************
3115 @GC_SEL_ABANDONED@: we could've done the selection, but we gave up
3116 (e.g., to avoid overflowing the C stack); @GC_SEL_MINOR@: did a
3117 selection in a minor GC; @GC_SEL_MAJOR@: ditto, but major GC.
3123 We're nuking the following:
3130 Return in registers.
3131 This lets us remove update code pointers from info tables,
3132 removes the need for phantom info tables, simplifies
3137 Careful analysis suggests that it doesn't buy us very much
3138 and it is hard to work with.
3140 Eliminating threaded GCs eliminates the desire to share SMReps
3141 so they are (once more) part of the Info table.
3145 Doesn't buy us anything on a register-poor architecture and
3146 isn't so important if we have semi-tagging.
3149 - Probably bad on register poor architecture
3150 - Can avoid need to write return address to stack on reg rich arch.
3151 - when a function does a small amount of work, doesn't
3152 enter any other thunks and then returns.
3153 eg entering a known constructor (but semitagging will catch this)
3154 - Adds complications
3160 This lets us drop CONST closures and CHARLIKE closures (assuming we
3161 don't support Unicode). The only point of these closures was to
3162 avoid updating with an indirection.
3164 We also drop @MIN_UPD_SIZE@ --- all we need is space to insert an
3165 indirection or a black hole.
3168 STATIC SMReps are now called CONST
3173 \item The profiling ``kind'' field is now encoded in the @INFO_TYPE@ field.
3174 This identifies the general sort of the closure for profiling purposes.
3176 \item Various papers describe deleting update frames for unreachable objects.
3177 This has never been implemented and we don't plan to anytime soon.
3181 \section{Old tricks}
3185 These are statically defined closures which have been updated with a
3186 heap-allocated result. Initially these are exactly the same as a
3187 @STATIC@ closure but with special entry code. On entering the closure
3188 the entry code must:
3191 \item Allocate a black hole in the heap which will be updated with
3193 \item Overwrite the static closure with a special @CAF@ indirection.
3195 \item Link the static indirection onto the list of updated @CAF@s.
3198 The indirection and the link field require the initial @STATIC@
3199 closure to be of at least size @MIN_UPD_SIZE@ (excluding the fixed
3202 @CAF@s are treated as special garbage collection roots. These roots
3203 are explicitly collected by the garbage collector, since they may
3204 appear in code even if they are not linked with the main heap. They
3205 consequently represent potentially enormous space-leaks. A @CAF@
3206 closure retains a fixed location in statically allocated data space.
3207 When updated, the contents of the @CAF@ indirection are changed to
3208 reflect the new closure. @CAF@ indirections require special garbage
3211 \section{Old stuff about SRTs}
3213 Garbage collection of @CAF@s is tricky. We have to cope with explicit
3214 collection from the @CAFlist@ as well as potential references from the
3215 stack and heap which will cause the @CAF@ evacuation code to be
3216 called. They are treated like indirections which are shorted out.
3217 However they must also be updated to point to the new location of the
3218 new closure as the @CAF@ may still be used by references which
3221 {\bf Copying Collection}
3223 A first scheme might use evacuation code which evacuates the reference
3224 and updates the indirection. This is no good as subsequent evacuations
3225 will result in an already evacuated closure being evacuated. This will
3226 leave a forward reference in to-space!
3228 An alternative scheme evacuates the @CAFlist@ first. The closures
3229 referenced are evacuated and the @CAF@ indirection updated to point to
3230 the evacuated closure. The @CAF@ evacuation code simply returns the
3231 updated indirection pointer --- the pointer to the evacuated closure.
3232 Unfortunately the closure the @CAF@ references may be a static
3233 closure, in fact, it may be another @CAF@. This will cause the second
3234 @CAF@'s evacuation code to be called before the @CAF@ has been
3235 evacuated, returning an unevacuated pointer.
3237 Another scheme leaves updating the @CAF@ indirections to the end of
3238 the garbage collection. All the references are evacuated and
3239 scavenged as usual (including the @CAFlist@). Once collection is
3240 complete the @CAFlist@ is traversed updating the @CAF@ references with
3241 the result of evacuating the referenced closure again. This will
3242 immediately return as it must be a forward reference, a static
3243 closure, or a @CAF@ which will indirect by evacuating its reference.
3245 The crux of the problem is that the @CAF@ evacuation code needs to
3246 know if its reference has already been evacuated and updated. If not,
3247 then the reference can be evacuated, updated and returned safely
3248 (possibly evacuating another @CAF@). If it has, then the updated
3249 reference can be returned. This can be done using two @CAF@
3250 info-tables. At the start of a collection the @CAFlist@ is traversed
3251 and set to an internal {\em evacuate and update} info-table. During
3252 collection, evacution of such a @CAF@ also results in the info-table
3253 being reset back to the standard @CAF@ info-table. Thus subsequent
3254 evacuations will simply return the updated reference. On completion of
3255 the collection all @CAF@s will have {\em return reference} info-tables
3258 This is the scheme we adopt. A @CAF@ indirection has evacuation code
3259 which returns the evacuated and updated reference. During garbage
3260 collection, all the @CAF@s are overwritten with an internal @CAF@ info
3261 table which has evacuation code which performs this evacuate and
3262 update and restores the original @CAF@ code. At some point during the
3263 collection we must ensure that all the @CAF@s are indeed evacuated.
3265 The only potential problem with this scheme is a cyclic list of @CAF@s
3266 all directly referencing (possibly via indirections) another @CAF@!
3267 Evacuation of the first @CAF@ will fail in an infinite loop of @CAF@
3268 evacuations. This is solved by ensuring that the @CAF@ info-table is
3269 updated to a {\em return reference} info-table before performing the
3270 evacuate and update. If this {\em return reference} evacuation code is
3271 called before the actual evacuation is complete it must be because
3272 such a cycle of references exists. Returning the still unevacuated
3273 reference is OK --- all the @CAF@s will now reference the same
3274 @CAF@ which will reference itself! Construction of such a structure
3275 indicates the program must be in an infinite loop.
3277 {\bf Compacting Collector}
3279 When shorting out a @CAF@, its reference must be marked. A first
3280 attempt might explicitly mark the @CAF@s, updating the reference with
3281 the marked reference (possibly short circuting indirections). The
3282 actual @CAF@ marking code can indicate that they have already been
3283 marked (though this might not have actually been done yet) and return
3284 the indirection pointer so it is shorted out. Unfortunately the @CAF@
3285 reference might point to an indirection which will be subsequently
3286 shorted out. Rather than returning the @CAF@ reference we treat the
3287 @CAF@ as an indirection, calling the mark code of the reference, which
3288 will return the appropriately shorted reference.
3290 Problem: Cyclic list of @CAF@s all directly referencing (possibly via
3291 indirections) another @CAF@!
3293 Before compacting, the locations of the @CAF@ references are
3294 explicitly linked to the closures they reference (if they reference
3295 heap allocated closures) so that the compacting process will update
3296 them to the closure's new location. Unfortunately these locations'
3297 @CAF@ indirections are static. This causes premature termination
3298 since the test to find the info pointer at the end of the location
3299 list will match more than one value. This can be solved by using an
3300 auxiliary dynamic array (on the top of the A stack). One location for
3301 each @CAF@ indirection is linked to the closure that the @CAF@
3302 references. Once collection is complete this array is traversed and
3303 the corresponding @CAF@ is then updated with the updated pointer from
3304 the auxiliary array.
3307 It is possible to use an alternative marking scheme, using a similar
3308 idea to the copying solution. This scheme avoids the need to update
3309 the @CAF@ references explicitly. We introduce an auxillary {\em mark
3310 and update} @CAF@ info-table which is used to update all @CAF@s at the
3311 start of a collection. The new code marks the @CAF@ reference,
3312 updating it with the returned reference. The returned reference is
3313 itself returned so the @CAF@ is shorted out. The code also modifies the
3314 @CAF@ info-table to be a {\em return reference}. Subsequent attempts to
3315 mark the @CAF@ simply return the updated reference.
3317 A cyclic @CAF@ reference will result in an attempt to mark the @CAF@
3318 before the marking has been completed and the reference updated. We
3319 cannot start marking the @CAF@ as it is already being marked. Nor can
3320 we return the reference as it has not yet been updated. Neither can we
3321 treat the CAF as an indirection since the @CAF@ reference has been
3322 obscured by the pointer reversal stack. All we can do is return the
3323 @CAF@ itself. This will result in some @CAF@ references not being
3326 This scheme has not been adopted but has been implemented. The code is
3327 commented out with @#if 0@.
3329 \subsection{The virtual register set}
3331 We refer to any (atomic) part of the virtual machine state as a ``register.''
3332 These ``registers'' may be shared between all threads in the system or may be
3333 specific to each thread.
3339 Thread preemption flag
3344 TSO - pointer to the TSO for when we have to pack thread away
3347 Su - used to calculate number of arguments on stack
3348 - this is a more convenient representation
3349 Call/return registers (aka General purpose registers)
3350 Cost centre (and other debug/profile info)
3351 Statistic gathering (not in production system)
3353 Heap overflow - possible global?
3354 Stack overflow - possibly global?
3355 Pattern match failure
3356 maybe a failWith handler?
3357 maybe an exitWith handler?
3361 Some of these virtual ``registers'' are used very frequently and should
3362 be mapped onto machine registers if at all possible. Others are used
3363 very infrequently and can be kept in memory to free up registers for
3366 On register-poor architectures, we can play a few tricks to reduce the
3367 number of virtual registers which need to be accessed on a regular
3372 - Grow stack and heap towards each other (single-threaded system only)
3373 - We might need to keep the C stack pointer in a register if that
3374 is what the OS expects when a signal occurs.
3375 - Preemption flag trick
3376 - If any of the frequently accessed registers cannot be mapped onto
3377 machine registers we should keep the TSO in a machine register to
3378 allow faster access to all the other non-machine registers.
projects / ghc-hetmet.git / blob