2 % (c) The OBFUSCATION-THROUGH-GRATUITOUS-PREPROCESSOR-ABUSE Project,
3 % Glasgow University, 1990-1994
8 % o I (ADR) 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.
14 % \documentstyle[preprint]{acmconf}
15 \documentclass[11pt]{article}
16 \oddsidemargin 0.1 in % Note that \oddsidemargin = \evensidemargin
17 \evensidemargin 0.1 in
18 \marginparwidth 0.85in % Narrow margins require narrower marginal notes
24 %\newcommand{\note}[1]{{\em Note: #1}}
25 \newcommand{\note}[1]{{{\bf Note:}\sl #1}}
26 \newcommand{\ToDo}[1]{{{\bf ToDo:}\sl #1}}
27 \newcommand{\Arg}[1]{\mbox{${\tt arg}_{#1}$}}
28 \newcommand{\bottom}{bottom} % foo, can't remember the symbol name
30 \newcommand{\secref}[1]{Section~\ref{sec:#1}}
31 \newcommand{\figref}[1]{Figure~\ref{fig:#1}}
32 \newcommand{\Section}[2]{\section{#1}\label{sec:#2}}
33 \newcommand{\Subsection}[2]{\subsection{#1}\label{sec:#2}}
34 \newcommand{\Subsubsection}[2]{\subsubsection{#1}\label{sec:#2}}
45 \setlength{\parskip}{0.15cm}
46 \setlength{\parsep}{0.15cm}
47 \setlength{\topsep}{0cm} % Reduces space before and after verbatim,
48 % which is implemented using trivlist
49 \setlength{\parindent}{0cm}
51 \renewcommand{\textfraction}{0.2}
52 \renewcommand{\floatpagefraction}{0.7}
56 \title{The STG runtime system (revised)}
57 \author{Simon Peyton Jones \\ Microsoft Research Ltd., Cambridge \and
58 Simon Marlow \\ Microsoft Research Ltd., Cambridge \and
59 Alastair Reid \\ Yale University}
67 \Section{Overview}{overview}
69 This document describes the GHC/Hugs run-time system. It serves as
70 a Glasgow/Yale/Nottingham ``contract'' about what the RTS does.
72 \Subsection{New features compared to GHC 3.xx}{new-features}
75 \item The RTS supports mixed compiled/interpreted execution, so
76 that a program can consist of a mixture of GHC-compiled and Hugs-interpreted
79 \item The RTS supports concurrency by default.
80 This has some costs (eg we can't do hardware stack checks) but
81 reduces the number of different configurations we need to support.
83 \item CAFs are only retained if they are
84 reachable. Since they are referred to by implicit references buried
85 in code, this means that the garbage collector must traverse the whole
86 accessible code tree. This feature eliminates a whole class of painful
89 \item A running thread has only one stack, which contains a mixture of
90 pointers and non-pointers. \secref{TSO} describes how we find out
91 which is which. (GHC has used two stacks for some while. Using one
92 stack instead of two reduces register pressure, reduces the size of
93 update frames, and eliminates ``stack-stubbing'' instructions.)
95 \item The ``return in registers'' return convention has been dropped
96 because it was complicated and doesn't work well on register-poor
97 architectures. It has been partly replaced by unboxed tuples
98 (\secref{unboxed-tuples}) which allow the programmer to
99 explicitly state where results should be returned in registers (or on
100 the stack) instead of on the heap.
102 \item Exceptions are supported by the RTS.
104 \item Weak Pointers generalise the previously available Foreign Object
107 \item The garbage collector supports a number of new features,
108 including a dynamically resizable heap and multiple generations with
109 aging within a generation.
113 \Subsection{Wish list}{wish-list}
115 Here's a list of things we'd like to support in the future.
117 \item Interrupts, speculative computation.
120 The SM could tune the size of the allocation arena, the number of
121 generations, etc taking into account residency, GC rate and page fault
125 We could trigger a GC when all threads are blocked waiting for IO if
126 the allocation arena (or some of the generations) are nearly full.
130 \Subsection{Configuration}{configuration}
132 Some of the above features are expensive or less portable, so we
133 envision building a number of different configurations supporting
134 different subsets of the above features.
136 You can make the following choices:
139 Support for parallelism. There are three mutually-exclusive choices.
142 \item[@SEQUENTIAL@] Support for concurrency but not for parallelism.
143 \item[@GRANSIM@] Concurrency support and simulated parallelism.
144 \item[@PARALLEL@] Concurrency support and real parallelism.
147 \item @PROFILING@ adds cost-centre profiling.
149 \item @TICKY@ gathers internal statistics (often known as ``ticky-ticky'' code).
151 \item @DEBUG@ does internal consistency checks.
153 \item Persistence. (well, not yet).
156 Which garbage collector to use. At the moment we
157 only anticipate one, however.
160 \Subsection{Glossary}{glossary}
162 \ToDo{This terminology is not used consistently within the document.
163 If you find something which disagrees with this terminology, fix the
166 In the type system, we have boxed and unboxed types.
170 \item A \emph{pointed} type is one that contains $\bot$. Variables with
171 pointed types are the only things which can be lazily evaluated. In
172 the STG machine, this means that they are the only things that can be
173 \emph{entered} or \emph{updated} and it requires that they be boxed.
175 \item An \emph{unpointed} type is one that does not contain $\bot$.
176 Variables with unpointed types are never delayed --- they are always
177 evaluated when they are constructed. In the STG machine, this means
178 that they cannot be \emph{entered} or \emph{updated}. Unpointed objects
179 may be boxed (like @Array#@) or unboxed (like @Int#@).
183 In the implementation, we have different kinds of objects:
187 \item \emph{boxed} objects are heap objects used by the evaluators
189 \item \emph{unboxed} objects are not heap allocated
191 \item \emph{stack} objects are allocated on the stack
193 \item \emph{closures} are objects which can be \emph{entered}.
194 They are always boxed and always have boxed types.
195 They may be in WHNF or they may be unevaluated.
197 \item A \emph{thunk} is a (representation of) a value of a \emph{pointed}
198 type which is \emph{not} in WHNF.
200 \item A \emph{value} is an object in WHNF. It can be pointed or unpointed.
206 At the hardware level, we have \emph{word}s and \emph{pointer}s.
210 \item A \emph{word} is (at least) 32 bits and can hold either a signed
213 \item A \emph{pointer} is (at least) 32 bits and big enough to hold a
214 function pointer or a data pointer.
218 Occasionally, a field of a data structure must hold either a word or a
219 pointer. In such circumstances, it is \emph{not safe} to assume that
220 words and pointers are the same size. \ToDo{GHC currently makes words
221 the same size as pointers to reduce complexity in the code
222 generator/RTS. It would be useful to relax this restriction, and have
223 eg. 32-bit Ints on a 64-bit machine.}
225 \subsection{Subtle Dependencies}
227 Some decisions have very subtle consequences which should be written
228 down in case we want to change our minds.
234 If the garbage collector is allowed to shrink the stack of a thread,
235 we cannot omit the stack check in return continuations
236 (\secref{heap-and-stack-checks}).
240 When we return to the scheduler, the top object on the stack is a closure.
241 The scheduler restarts the thread by entering the closure.
243 \secref{hugs-return-convention} discusses how Hugs returns an
244 unboxed value to GHC and how GHC returns an unboxed value to Hugs.
248 When we return to the scheduler, we need a few empty words on the stack
249 to store a closure to reenter. \secref{heap-and-stack-checks}
250 discusses who does the stack check and how much space they need.
254 Heap objects never contain slop --- this is required if we want to
255 support mostly-copying garbage collection.
257 This is a big problem when updating since the updatee is usually
258 bigger than an indirection object. The fix is to overwrite the end of
259 the updatee with ``slop objects'' (described in
260 \secref{slop-objects}). This is hard to arrange if we do
261 \emph{lazy} blackholing (\secref{lazy-black-holing}) so we
262 currently plan to blackhole an object when we push the update frame.
264 % Idea: have specialised update code for various common sizes of
265 % updatee, the update frame hence encodes the length of the object.
266 % Specialised indirections will also encode the length of the object. A
267 % generic version of the update code will overwrite the slop with a slop
268 % object. We can do the same thing for blackhole objects, or just have
269 % a generic version that is the same size as an indirection and
270 % overwrite the slop with a slop object when blackholing. So: does this
271 % avoid the need to do eager black holing?
275 Info tables for constructors contain enough information to decide which
276 return convention they use. This allows Hugs to use a single piece of
277 entry code for all constructors and insulates Hugs from changes in the
278 choice of return convention.
282 \Section{Source Language}{source-language}
284 \Subsection{Explicit Allocation}{explicit-allocation}
286 As in the original STG machine, (almost) all heap allocation is caused
287 by executing a let(rec). Since we no longer support the return in
288 registers convention for data constructors, constructors now cause heap
289 allocation and so they should be let-bound.
291 For example, we now write
293 > cons = \ x xs -> let r = (:) x xs in r
297 > cons = \ x xs -> (:) x xs
300 \note{For historical reasons, GHC doesn't use this syntax --- but it should.}
302 \Subsection{Unboxed tuples}{unboxed-tuples}
304 Functions can take multiple arguments as easily as they can take one
305 argument: there's no cost for adding another argument. But functions
306 can only return one result: the cost of adding a second ``result'' is
307 that the function must construct a tuple of ``results'' on the heap.
308 The assymetry is rather galling and can make certain programming
309 styles quite expensive. For example, consider a simple state transformer
312 > type S a = State -> (a,State)
313 > bindS m k s0 = case m s0 of { (a,s1) -> k a s1 }
314 > returnS a s = (a,s)
318 Here, every use of @returnS@, @getS@ or @setS@ constructs a new tuple
319 in the heap which is instantly taken apart (and becomes garbage) by
320 the case analysis in @bind@. Even a short state-transformer program
321 will construct a lot of these temporary tuples.
323 Unboxed tuples provide a way for the programmer to indicate that they
324 do not expect a tuple to be shared and that they do not expect it to
325 be allocated in the heap. Syntactically, unboxed tuples are just like
326 single constructor datatypes except for the annotation @unboxed@.
328 > data unboxed AAndState# a = AnS a State
329 > type S a = State -> AAndState# a
330 > bindS m k s0 = case m s0 of { AnS a s1 -> k a s1 }
331 > returnS a s = AnS a s
333 > setS s _ = AnS () s
335 Semantically, unboxed tuples are just unlifted tuples and are subject
336 to the same restrictions as other unpointed types.
338 Operationally, unboxed tuples are never built on the heap. When
339 an unboxed tuple is returned, it is returned in multiple registers
340 or multiple stack slots. At first sight, this seems a little strange
341 but it's no different from passing double precision floats in two
347 Unboxed tuples can only have one constructor and that
348 thunks never have unboxed types --- so we'll never try to update an
349 unboxed constructor. The restriction to a single constructor is
350 largely to avoid garbage collection complications.
353 The core syntax does not allow variables to be bound to
354 unboxed tuples (ie in default case alternatives or as function arguments)
355 and does not allow unboxed tuples to be fields of other constructors.
356 However, there's no harm in allowing it in the source syntax as a
357 convenient, but easily removed, syntactic sugar.
360 The compiler generates a closure of the form
362 > c = \ x y z -> C x y z
364 for every constructor (whether boxed or unboxed).
366 This closure is normally used during desugaring to ensure that
367 constructors are saturated and to apply any strictness annotations.
368 They are also used when returning unboxed constructors to the machine
369 code evaluator from the bytecode evaluator and when a heap check fails
370 in a return continuation for an unboxed-tuple scrutinee.
374 \Subsection{STG Syntax}{stg-syntax}
377 \ToDo{Insert STG syntax with appropriate changes.}
380 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
381 \part{System Overview}
382 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
384 This part is concerned with defining the external interfaces of the
385 major components of the system; the next part is concerned with their
388 The major components of the system are:
393 The evaluators (\secref{sm-overview}) are responsible for
394 evaluating heap objects. The system supports two evaluators: the
395 machine code evaluator; and the bytecode evaluator.
399 The scheduler (\secref{scheduler-overview}) acts as the
400 coordinator for the whole system. It is responsible for switching
401 between evaluators, switching between threads, garbage collection,
402 communication between multiple processors, etc.
406 The storage manager (\secref{evaluators-overview}) is
407 responsible for allocating blocks of contiguous memory and for garbage
412 The loader (\secref{loader-overview}) is responsible for
413 loading machine code and bytecode files from the file system and for
414 resolving references between separately compiled modules.
418 The compilers (\secref{compilers-overview}) generate machine
419 code and bytecode files which can be loaded by the loader.
423 \ToDo{Insert diagram showing all components underneath the scheduler
424 and communicating only with the scheduler}
427 \Section{The Evaluators}{evaluators-overview}
429 There are two evaluators: a machine code evaluator and a bytecode
430 evaluator. The evaluators task is to evaluate code within a thread
431 until one of the following happens:
436 \item it is preempted
437 \item it blocks in one of the concurrency primitives
438 \item it performs a safe ccall
439 \item it needs to switch to the other evaluator.
442 The evaluators expect to find a closure on top of the thread's stack
443 and terminate with a closure on top of the thread's stack.
445 \Subsection{Evaluation Model}{evaluation-model}
447 Whilst the evaluators differ internally, they share a common
448 evaluation model and many object representations.
450 \Subsubsection{Heap objects}{heap-objects-overview}
452 The choice of heap and stack objects used by the evaluators is tightly
453 bound to the evaluation model. This section provides an overview of
454 the most important heap and stack objects; further details are given
457 All heap objects look like this:
460 \begin{tabular}{|l|l|l|l|}\hline
461 \emph{Header} & \emph{Payload} \\ \hline
465 The headers vary between different kinds of object but they all start
466 with a pointer to a pair consisting of an \emph{info table} and some
467 \emph{entry code}. The info table is used both by the evaluators and
468 by the storage manager and contains a @type@ field which identifies
469 which kind of heap object uses it and determines the interpretation of
470 the payload and of the other fields of the info table. The entry code
471 is some machine code used by the machine code evaluator to evaluate
472 closures and raises an error for other kinds of objects.
474 The major kinds of heap object used are as follows. (For simplicity,
475 this description omits certain optimisations and extra fields required
476 by the garbage collector.)
480 \item[Constructors] are used to represent data constructors. Their
481 payload consists of the fields of the constructor; the tag of the
482 constructor is stored in the info table.
485 \begin{tabular}{|l|l|l|l|}\hline
486 @CONSTR@ & \emph{Fields} \\ \hline
490 \item[Primitive objects] are used to represent objects with unlifted
491 types which are too large to fit in a register (or stack slot) or for
492 which sharing must be preserved. Primitive objects include large
493 objects such as multiple precision integers and immutable arrays and
494 mutable objects such as mutable arrays, mutable variables, MVar's,
495 IVar's and foreign object pointers. Since primitive objects are not
496 lifted, they cannot be entered. Their payload varies according to the
499 \item[Function closures] are used to represent functions. Their
500 payload (if any) consists of the free variables of the function.
503 \begin{tabular}{|l|l|l|l|}\hline
504 @FUN@ & \emph{Free Variables} \\ \hline
508 Function closures are only generated by the machine code compiler.
510 \item[Thunks] are used to represent unevaluated expressions which will
511 be updated with their result. Their payload (if any) consists of the
512 free variables of the function. The entry code for a thunk starts by
513 pushing an \emph{update frame} onto the stack. When evaluation of the
514 thunk completes, the update frame will cause the thunk to be
515 overwritten again with an \emph{indirection} to the result of the
516 thunk, which is always a constructor or a partial application.
519 \begin{tabular}{|l|l|l|l|}\hline
520 @THUNK@ & \emph{Free Variables} \\ \hline
524 Thunks are only generated by the machine code evaluator.
526 \item[Byte-code Objects (@BCO@s)] are generated by the bytecode
527 compiler. In conjunction with \emph{updatable applications} and
528 \emph{non-updatable applications} they are used to represent
529 functions, unevaluated expressions and return addresses.
532 \begin{tabular}{|l|l|l|l|}\hline
533 @BCO@ & \emph{Constant Pool} & \emph{Bytecodes} \\ \hline
537 \item[Non-updatable (Partial) Applications] are used to represent the
538 application of a function to an insufficient number of arguments.
539 Their payload consists of the function and the arguments received so far.
542 \begin{tabular}{|l|l|l|l|}\hline
543 @PAP@ & \emph{Function Closure} & \emph{Arguments} \\ \hline
547 @PAP@s are used when a function is applied to too few arguments and by
548 code generated by the lambda-lifting phase of the bytecode compiler.
550 \item[Updatable Applications] are used to represent the application of
551 a function to a sufficient number of arguments. Their payload
552 consists of the function and its arguments.
554 Updateable applications are like thunks: on entering an updateable
555 application, the evaluators push an \emph{update frame} onto the stack
556 and overwrite the application with a \emph{black hole}; when
557 evaluation completes, the evaluators overwrite the application with an
558 \emph{indirection} to the result of the application.
561 \begin{tabular}{|l|l|l|l|}\hline
562 @AP@ & \emph{Function Closure} & \emph{Arguments} \\ \hline
566 @AP@s are only generated by the bytecode compiler.
568 \item[Black holes] are used to mark updateable closures which are
569 currently being evaluated. ``Black holing'' an object cures a
570 potential space leak and detects certain classes of infinite loops.
571 More imporantly, black holes act as synchronisation objects between
572 separate threads: if a second thread tries to enter an updateable
573 closure which is already being evaluated, the second thread is added
574 to a list of blocked threads and the thread is suspended.
576 When evaluation of the black-holed closure completes, the black hole
577 is overwritten with an indirection to the result of the closure and
578 any blocked threads are restored to the runnable queue.
580 Closures are overwritten by black-holes during a ``lazy black-holing''
581 phase which runs on each thread when it returns to the scheduler.
582 \ToDo{section describing lazy black-holing}.
585 \begin{tabular}{|l|l|l|l|}\hline
586 @BLACKHOLE@ & \emph{Blocked threads} \\ \hline
590 \ToDo{In a single threaded system, it's trivial to detect infinite
591 loops: reentering a BLACKHOLE is always an error. How easy is it in a
592 multi-threaded system?}
594 \item[Indirections] are used to update an unevaluated closure with its
595 (usually fully evaluated) result in situations where it isn't possible
596 to perform an update in place. (In the current system, we always
597 update with an indirection to avoid duplicating the result when doing
601 \begin{tabular}{|l|l|l|l|}\hline
602 @IND@ & \emph{Closure} \\ \hline
606 Indirections needn't always point to a closure in WHNF. They can
607 point to a chain of indirections which point to an evaluated closure.
609 \item[Thread State Objects (@TSO@s)] represent Haskell threads. Their
610 payload consists of some per-thread information such as the Thread ID
611 and the status of the thread (runnable, blocked etc.), and the
612 thread's stack. See @TSO.h@ for the full story. @TSO@s may be
613 resized by the scheduler if its stack is too small or too large.
615 The thread stack grows downwards from higher to lower addresses.
618 \begin{tabular}{|l|l|l|l|}\hline
619 @TSO@ & \emph{Thread info} & \emph{Stack} \\ \hline
625 \Subsubsection{Stack objects}{stack-objects-overview}
627 The stack contains a mixture of \emph{pending arguments} and
628 \emph{stack objects}.
630 Pending arguments are arguments to curried functions which have not
631 yet been incorporated into an activation frame. For example, when
632 evaluating @let { g x y = x + y; f x = g{x} } in f{3,4}@, the
633 evaluator pushes both arguments onto the stack and enters @f@. @f@
634 only requires one argument so it leaves the second argument as a
635 \emph{pending argument}. The pending argument remains on the stack
636 until @f@ calls @g@ which requires two arguments: the argument passed
637 to it by @f@ and the pending argument which was passed to @f@.
639 Unboxed pending arguments are always preceeded by a ``tag'' which says
640 how large the argument is. This allows the garbage collector to
641 locate pointers within the stack.
643 There are three kinds of stack object: return addresses, update frames
644 and seq frames. All stack objects look like this
647 \begin{tabular}{|l|l|l|l|}\hline
648 \emph{Header} & \emph{Payload} \\ \hline
652 As with heap objects, the header starts with a pointer to a pair
653 consisting of an \emph{info table} and some \emph{entry code}.
657 \item[Return addresses] are used to cause selection and execution of
658 case alternatives when a constructor is returned. Return addresses
659 generated by the machine code compiler look like this:
662 \begin{tabular}{|l|l|l|l|}\hline
663 \emph{@RET_XXX@} & \emph{Free Variables of the case alternatives} \\ \hline
667 The free variables are a mixture of pointers and non-pointers whose
668 layout is described by a bitmask in the info table.
670 There are several kinds of @RET_XXX@ return address - see
671 \secref{activation-records} for the details.
673 Return addresses generated by the bytecode compiler look like this:
675 \begin{tabular}{|l|l|l|l|}\hline
676 \emph{@BCO_RET@} & \emph{BCO} & \emph{Free Variables of the case alternatives} \\ \hline
680 There is just one @BCO_RET@ info pointer. We avoid needing different
681 @BCO_RET@s for each stack layout by tagging unboxed free variables as
682 though they were pending arguments.
684 \item[Update frames] are used to trigger updates. When an update
685 frame is entered, it overwrites the updatee with an indirection to the
686 result, restarts any threads blocked on the @BLACKHOLE@ and returns to
687 the stack object underneath the update frame.
690 \begin{tabular}{|l|l|l|l|}\hline
691 \emph{@UPDATE_FRAME@} & \emph{Next Update Frame} & \emph{Updatee} \\ \hline
695 \item[Seq frames] are used to implement the polymorphic @seq@
696 primitive. They are a special kind of update frame, and are linked on
697 the update frame list.
700 \begin{tabular}{|l|l|l|l|}\hline
701 \emph{@SEQ_FRAME@} & \emph{Next Update Frame} \\ \hline
705 \item[Stop frames] are put on the bottom of each thread's stack, and
706 act as sentinels for the update frame list (i.e. the last update frame
707 points to the stop frame). Returning to a stop frame terminates the
708 thread. Stop frames have no payload:
711 \begin{tabular}{|l|l|l|l|}\hline
712 \emph{@SEQ_FRAME@} \\ \hline
718 \Subsubsection{Case expressions}{case-expr-overview}
720 In the STG language, all evaluation is triggered by evaluating a case
721 expression. When evaluating a case expression @case e of alts@, the
722 evaluators pushes a return address onto the stack and evaluate the
723 expression @e@. When @e@ eventually reduces to a constructor, the
724 return address on the stack is entered. The details of how the
725 constructor is passed to the return address and how the appropriate
726 case alternative is selected vary between evaluators.
728 Case expressions for unboxed data types are essentially the same: the
729 case expression pushes a return address onto the stack before
730 evaluating the scrutinee; when a function returns an unboxed value, it
731 enters the return address on top of the stack.
734 \Subsubsection{Function applications}{fun-app-overview}
736 In the STG language, all function calls are tail calls. The arguments
737 are pushed onto the stack and the function closure is entered. If any
738 arguments are unboxed, they must be tagged as unboxed pending
739 arguments. Entering a closure is just a special case of calling a
740 function with no arguments.
743 \Subsubsection{Let expressions}{let-expr-overview}
745 In the STG language, almost all heap allocation is caused by let
746 expressions. Filling in the contents of a set of mutually recursive
747 heap objects is simple enough; the only difficulty is that once the
748 heap space has been allocated, the thread must not return to the
749 scheduler until after the objects are filled in.
752 \Subsubsection{Primitive operations}{primop-overview}
756 Most primops are simple, some aren't.
763 \Section{Scheduler}{scheduler-overview}
765 The Scheduler is the heart of the run-time system. A running program
766 consists of a single running thread, and a list of runnable and
767 blocked threads. A thread is represented by a \emph{Thread Status
768 Object} (TSO), which contains a few words status information and a
769 stack. Except for the running thread, all threads have a closure on
770 top of their stack; the scheduler restarts a thread by entering an
771 evaluator which performs some reduction and returns to the scheduler.
773 \Subsection{The scheduler's main loop}{scheduler-main-loop}
775 The scheduler consists of a loop which chooses a runnable thread and
776 invokes one of the evaluators which performs some reduction and
779 The scheduler also takes care of system-wide issues such as heap
780 overflow or communication with other processors (in the parallel
781 system) and thread-specific problems such as stack overflow.
783 \Subsection{Creating a thread}{create-thread}
791 When the scheduler is first invoked.
795 When a message is received from another processor (I think). (Parallel
800 When a C program calls some Haskell code.
804 By @forkIO@, @takeMVar@ and (maybe) other Concurrent Haskell primitives.
809 \Subsection{Restarting a thread}{thread-restart}
811 When the scheduler decides to run a thread, it has to decide which
812 evaluator to use. It does this by looking at the type of the closure
815 \item @BCO@ $\Rightarrow$ bytecode evaluator
816 \item @FUN@ or @THUNK@ $\Rightarrow$ machine code evaluator
817 \item @CONSTR@ $\Rightarrow$ machine code evaluator
818 \item other $\Rightarrow$ either evaluator.
821 The only surprise in the above is that the scheduler must enter the
822 machine code evaluator if there's a constructor on top of the stack.
823 This allows the bytecode evaluator to return a constructor to a
824 machine code return address by pushing the constructor on top of the
825 stack and returning to the scheduler. If the return address under the
826 constructor is @HUGS_RET@, the entry code for @HUGS_RET@ will
827 rearrange the stack so that the return @BCO@ is on top of the stack
828 and return to the scheduler which will then call the bytecode
829 evaluator. There is little point in trying to shorten this slightly
830 indirect route since it is will happen very rarely if at all.
832 \note{As an optimisation, we could store the choice of evaluator in
833 the TSO status whenever we leave the evaluator. This is required for
834 any thread, no matter what state it is in (blocked, stack overflow,
835 etc). It isn't clear whether this would accomplish anything.}
837 \Subsection{Returning from a thread}{thread-return}
839 The evaluators return to the scheduler when any of the following
843 \item A heap check fails, and a garbage collection is required.
845 \item A stack check fails, and the scheduler must either enlarge the
846 current thread's stack, or flag an out of memory condition.
848 \item A thread enters a closure built by the other evaluator. That
849 is, when the bytecode interpreter enters a closure compiled by GHC or
850 when the machine code evaluator enters a BCO.
852 \item A thread returns to a return continuation built by the other
853 evaluator. That is, when the machine code evaluator returns to a
854 continuation built by Hugs or when the bytecode evaluator returns to a
855 continuation built by GHC.
857 \item The evaluator needs to perform a ``safe'' C call
860 \item The thread becomes blocked. This happens when a thread requires
861 the result of a computation currently being performed by another
862 thread, or it reads a synchronisation variable that is currently empty
865 \item The thread is preempted (the preemption mechanism is described
866 in \secref{thread-preemption}).
868 \item The thread terminates.
871 Except when the thread terminates, the thread always terminates with a
872 closure on the top of the stack. The mechanism used to trigger the
873 world switch and the choice of closure left on top of the stack varies
874 according to which world is being left and what is being returned.
876 \Subsubsection{Leaving the bytecode evaluator}{hugs-to-ghc-switch}
878 \paragraph{Entering a machine code closure}
880 When it enters a closure, the bytecode evaluator performs a switch
881 based on the type of closure (@AP@, @PAP@, @Ind@, etc). On entering a
882 machine code closure, it returns to the scheduler with the closure on
885 \paragraph{Returning a constructor}
887 When it enters a constructor, the bytecode evaluator tests the return
888 continuation on top of the stack. If it is a machine code
889 continuation, it returns to the scheduler with the constructor on top
892 \note{This is why the scheduler must enter the machine code evaluator
893 if it finds a constructor on top of the stack.}
895 \paragraph{Returning an unboxed value}
897 \note{Hugs doesn't support unboxed values in source programs but they
898 are used for a few complex primops.}
900 When it returns an unboxed value, the bytecode evaluator tests the
901 return continuation on top of the stack. If it is a machine code
902 continuation, it returns to the scheduler with the tagged unboxed
903 value and a special closure on top of the stack. When the closure is
904 entered (by the machine code evaluator), it returns the unboxed value
905 on top of the stack to the return continuation under it.
907 The runtime library for GHC provides one of these closures for each unboxed
908 type. Hugs cannot generate them itself since the entry code is really
911 \paragraph{Heap/Stack overflow and preemption}
913 The bytecode evaluator tests for heap/stack overflow and preemption
914 when entering a BCO and simply returns with the BCO on top of the
917 \Subsubsection{Leaving the machine code evaluator}{ghc-to-hugs-switch}
919 \paragraph{Entering a BCO}
921 The entry code for a BCO pushes the BCO onto the stack and returns to
924 \paragraph{Returning a constructor}
926 We avoid the need to test return addresses in the machine code
927 evaluator by pushing a special return address on top of a pointer to
928 the bytecode return continuation. \figref{hugs-return-stack}
929 shows the state of the stack just before evaluating the scrutinee.
941 %\input{hugs_return1.pstex_t}
943 \caption{Stack layout for evaluating a scrutinee}
944 \label{fig:hugs-return-stack}
947 This return address rearranges the stack so that the bco pointer is
948 above the constructor on the stack (as shown in
949 \figref{hugs-boxed-return}) and returns to the scheduler.
956 | con |--> Constructor
961 %\input{hugs_return2.pstex_t}
963 \caption{Stack layout for entering a Hugs return address}
964 \label{fig:hugs-boxed-return}
967 \paragraph{Returning an unboxed value}
969 We avoid the need to test return addresses in the machine code
970 evaluator by pushing a special return address on top of a pointer to
971 the bytecode return continuation. This return address rearranges the
972 stack so that the bco pointer is above the tagged unboxed value (as
973 shown in \figref{hugs-entering-unboxed-return}) and returns to the
988 %\input{hugs_return2.pstex_t}
990 \caption{Stack layout for returning an unboxed value}
991 \label{fig:hugs-entering-unboxed-return}
994 \paragraph{Heap/Stack overflow and preemption}
999 \Subsection{Preempting a thread}{thread-preemption}
1001 Strictly speaking, threads cannot be preempted --- the scheduler
1002 merely sets a preemption request flag which the thread must arrange to
1003 test on a regular basis. When an evaluator finds that the preemption
1004 request flag is set, it pushes an appropriate closure onto the stack
1005 and returns to the scheduler.
1007 In the bytecode interpreter, the flag is tested whenever we enter a
1008 closure. If the preemption flag is set, it leaves the closure on top
1009 of the stack and returns to the scheduler.
1011 In the machine code evaluator, the flag is only tested when a heap or
1012 stack check fails. This is less expensive than testing the flag on
1013 entering every closure but runs the risk that a thread will enter an
1014 infinite loop which does not allocate any space. If the flag is set,
1015 the evaluator returns to the scheduler exactly as if a heap check had
1018 \Subsection{``Safe'' and ``unsafe'' C calls}{c-calls}
1020 There are two ways of calling C:
1024 \item[``Unsafe'' C calls] are used if the programer is certain that
1025 the C function will not do anything dangerous. Unsafe C calls are
1026 faster but must be hand-checked by the programmer.
1028 Dangerous things include:
1034 Call a system function such as @getchar@ which might block
1035 indefinitely. This is dangerous because we don't want the entire
1036 runtime system to block just because one thread blocks.
1040 Call an RTS function which will block on the RTS access semaphore.
1041 This would lead to deadlock.
1045 Call a Haskell function. This is just a special case of calling an
1050 Unsafe C calls are performed by pushing the arguments onto the C stack
1051 and jumping to the C function's entry point. On exit, the result of
1052 the function is in a register which is returned to the Haskell code as
1055 \item[``Safe'' C calls] are used if the programmer suspects that the
1056 thread may do something dangerous. Safe C calls are relatively slow
1057 but are less problematic.
1059 Safe C calls are performed by pushing the arguments onto the Haskell
1060 stack, pushing a return continuation and returning a \emph{C function
1061 descriptor} to the scheduler. The scheduler suspends the Haskell thread,
1062 spawns a new operating system thread which pops the arguments off the
1063 Haskell stack onto the C stack, calls the C function, pushes the
1064 function result onto the Haskell stack and informs the scheduler that
1065 the C function has completed and the Haskell thread is now runnable.
1069 The bytecode evaluator will probably treat all C calls as being safe.
1071 \ToDo{It might be good for the programmer to indicate how the program
1072 is unsafe. For example, if we distinguish between C functions which
1073 might call Haskell functions and those which might block, we could
1074 perform an unsafe call for blocking functions in a single-threaded
1075 system or, perhaps, in a multi-threaded system which only happens to
1076 have a single thread at the moment.}
1080 \Section{The Storage Manager}{sm-overview}
1082 The storage manager is responsible for managing the heap and all
1083 objects stored in it. It provides special support for lazy evaluation
1084 and for foreign function calls.
1086 \Subsection{SM support for lazy evaluation}{sm-lazy-evaluation}
1091 Indirections are shorted out.
1095 Update frames pointing to unreachable objects are squeezed out.
1099 Adjacent update frames (for different closures) are compressed to a
1100 single update frame pointing to a single black hole.
1105 \Subsection{SM support for foreign function calls}{sm-foreign-calls}
1111 Stable pointers allow other languages to access Haskell objects.
1115 Weak pointers and foreign objects provide finalisation support for
1116 Haskell references to external objects.
1120 \Subsection{Misc}{sm-misc}
1126 If the stack contains a large amount of free space, the storage
1127 manager may shrink the stack. If it shrinks the stack, it guarantees
1128 never to leave less than @MIN_SIZE_SHRUNKEN_STACK@ empty words on the
1129 stack when it does so.
1133 For efficiency reasons, very large objects (eg large arrays and TSOs)
1134 are not moved if possible.
1139 \Section{The Compilers}{compilers-overview}
1141 Need to describe interface files, format of bytecode files, symbols
1142 defined by machine code files.
1144 \Subsection{Interface Files}{interface-files}
1146 Here's an example - but I don't know the grammar - ADR.
1152 1 main _:_ IOBase.IO PrelBase.();;
1155 \Subsection{Bytecode files}{bytecode-files}
1157 (All that matters here is what the loader sees.)
1159 \Subsection{Machine code files}{asm-files}
1161 (Again, all that matters is what the loader sees.)
1163 \Section{The Loader}{loader-overview}
1165 In a batch mode system, we can statically link all the modules
1166 together. In an interactive system we need a loader which will
1167 explicitly load and unload individual modules (or, perhaps, blocks of
1168 mutually dependent modules) and resolve references between modules.
1170 While many operating systems provide support for dynamic loading and
1171 will automatically resolve cross-module references for us, we generally
1172 cannot rely on being able to load mutually dependent modules.
1174 A portable solution is to perform some of the linking ourselves. Each module
1175 should provide three global symbols:
1178 An initialisation routine. (Might also be used for finalisation.)
1180 A table of symbols it exports.
1181 Entries in this table consist of the symbol name and the address of the
1184 A table of symbols it imports.
1185 Entries in this table consist of the symbol name and a list of references
1189 On loading a group of modules, the loader adds the contents of the
1190 export lists to a symbol table and then fills in all the references in the
1193 References in import lists are of two types:
1195 \item[ References in machine code ]
1197 The most efficient approach is to patch the machine code directly, but
1198 this will be a lot of work, very painful to port and rather fragile.
1200 Alternatively, the loader could store the value of each symbol in the
1201 import table for each module and the compiled code can access all
1202 external objects through the import table. This requires that the
1203 import table be writable but does not require that the machine code or
1204 info tables be writable.
1206 \item[ References in data structures (SRTs and static data constructors) ]
1208 Either we patch the SRTs and constructors directly or we somehow use
1209 indirections through the symbol table. Patching the SRTs requires
1210 that we make them writable and prevents us from making effective use
1211 of virtual memories that use copy-on-write policies (this only makes a
1212 difference if we want to run several copies of the same program
1213 simultaneously). Using an indirection is possible but tricky.
1215 Note: We could avoid patching machine code if all references to
1216 external references went through the SRT --- then we just have one
1217 thing to patch. But the SRT always contains a pointer to the closure
1218 rather than the fast entry point (say), so we'd take a big performance
1223 Using the above scheme, all accesses to ``external'' objects involve a
1224 layer of indirection. To avoid this overhead, the machine code
1225 compiler might provide a way for the programmer to specify which
1226 modules will be statically linked and which will be dynamically linked
1227 --- the idea being that statically linked code and data will be
1231 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1232 \part{Internal details}
1233 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1235 This part is concerned with the internal details of the components
1236 described in the previous part.
1238 The major components of the system are:
1240 \item The scheduler (\secref{storage-manager-internals})
1241 \item The storage manager (\secref{storage-manager-internals})
1242 \item The evaluators
1247 \Section{The Scheduler}{scheduler-internals}
1249 \ToDo{Detailed description of scheduler}
1251 Many heap objects contain fields allowing them to be inserted onto lists
1252 during evaluation or during garbage collection. The lists required by
1253 the evaluator and storage manager are as follows.
1257 \item 4 lists of threads: runnable threads, sleeping threads, threads
1258 waiting for timeout and threads waiting for I/O.
1260 \item The \emph{mutables list} is a list of all objects in the old
1261 generation which might contain pointers into the new generation. Most
1262 of the objects on this list are indirections (\secref{IND})
1263 or ``mutable.'' (\secref{mutables}.)
1265 \item The \emph{Foreign Object list} is a list of all foreign objects
1266 which have not yet been deallocated. (\secref{FOREIGN}.)
1268 \item The \emph{Spark pool} is a doubly(?) linked list of Spark objects
1269 maintained by the parallel system. (\secref{SPARK}.)
1271 \item The \emph{Blocked Fetch list} (or
1272 lists?). (\secref{BLOCKED_FETCH}.)
1274 \item For each thread, there is a list of all update frames on the
1275 stack. (\secref{data-updates}.)
1277 \item The Stable Pointer Table is a table of pointers to objects which
1278 are known to the outside world and must be retained by the garbage
1279 collector even if they are not accessible from within the heap.
1283 \ToDo{The links for these fields are usually inserted immediately
1284 after the fixed header except ...}
1288 \Section{The Storage Manager}{storage-manager-internals}
1290 \subsection{Misc Text looking for a home}
1292 A \emph{value} may be:
1294 \item \emph{Boxed}, i.e.~represented indirectly by a pointer to a heap object (e.g.~foreign objects, arrays); or
1295 \item \emph{Unboxed}, i.e.~represented directly by a bit-pattern in one or more registers (e.g.~@Int#@ and @Float#@).
1297 All \emph{pointed} values are \emph{boxed}.
1300 \Subsection{Heap Objects}{heap-objects}
1301 \label{sec:fixed-header}
1307 \ToDo{Fix this picture}
1312 Every \emph{heap object} is a contiguous block of memory, consisting
1313 of a fixed-format \emph{header} followed by zero or more \emph{data
1316 The header consists of the following fields:
1318 \item A one-word \emph{info pointer}, which points to
1319 the object's static \emph{info table}.
1320 \item Zero or more \emph{admin words} that support
1322 \item Profiling (notably a \emph{cost centre} word).
1323 \note{We could possibly omit the cost centre word from some
1324 administrative objects.}
1325 \item Parallelism (e.g. GranSim keeps the object's global address here,
1326 though GUM keeps a separate hash table).
1327 \item Statistics (e.g. a word to track how many times a thunk is entered.).
1329 We add a Ticky word to the fixed-header part of closures. This is
1330 used to indicate if a closure has been updated but not yet entered. It
1331 is set when the closure is updated and cleared when subsequently
1332 entered. \footnote{% NB: It is \emph{not} an ``entry count'', it is
1333 an ``entries-after-update count.'' The commoning up of @CONST@,
1334 @CHARLIKE@ and @INTLIKE@ closures is turned off(?) if this is
1335 required. This has only been done for 2s collection. }
1340 Most of the RTS is completely insensitive to the number of admin
1341 words. The total size of the fixed header is given by
1342 @sizeof(StgHeader)@.
1344 \Subsection{Info Tables}{info-tables}
1346 An \emph{info table} is a contiguous block of memory, laid out as follows:
1349 \begin{tabular}{|r|l|}
1350 \hline Parallelism Info & variable
1351 \\ \hline Profile Info & variable
1352 \\ \hline Debug Info & variable
1353 \\ \hline Static reference table & pointer word (optional)
1354 \\ \hline Storage manager layout info & pointer word
1355 \\ \hline Closure flags & 8 bits
1356 \\ \hline Closure type & 8 bits
1357 \\ \hline Constructor Tag / SRT length & 16 bits
1358 \\ \hline entry code
1363 On a 64-bit machine the tag, type and flags fields will all be doubled
1364 in size, so the info table is a multiple of 64 bits.
1366 An info table has the following contents (working backwards in memory
1371 \item The \emph{entry code} for the closure. This code appears
1372 literally as the (large) last entry in the info table, immediately
1373 preceded by the rest of the info table. An \emph{info pointer} always
1374 points to the first byte of the entry code.
1376 \item A 16-bit constructor tag / SRT length. For a constructor info
1377 table this field contains the tag of the constructor, in the range
1378 $0..n-1$ where $n$ is the number of constructors in the datatype.
1379 Otherwise, it contains the number of entries in this closure's Static
1380 Reference Table (\secref{srt}).
1382 \item An 8-bit {\em closure type field}, which identifies what kind of
1383 closure the object is. The various types of closure are described in
1386 \item an 8-bit flags field, which holds various flags pertaining to
1389 \item A single pointer or word --- the {\em storage manager info
1390 field}, contains auxiliary information describing the closure's
1391 precise layout, for the benefit of the garbage collector and the code
1392 that stuffs graph into packets for transmission over the network.
1393 There are three kinds of layout information:
1396 \item Standard layout information is for closures which place pointers
1397 before non-pointers in instances of the closure (this applies to most
1398 heap-based and static closures, but not activation records). The
1399 layout information for standard closures is
1402 \item Number of pointer fields (16 bits).
1403 \item Number of non-pointer fields (16 bits).
1406 \item Activation records don't have pointers before non-pointers,
1407 since stack-stubbing requires that the record has holes in it. The
1408 layout is therefore represented by a bitmap in which each '1' bit
1409 represents a non-pointer word. This kind of layout info is used for
1410 @RET_SMALL@ and @RET_VEC_SMALL@ closures.
1412 \item If an activation record is longer than 32 words, then the layout
1413 field contains a pointer to a bitmap record, consisting of a length
1414 field followed by two or more bitmap words. This layout information
1415 is used for @RET_BIG@ and @RET_VEC_BIG@ closures.
1417 \item Selector Thunks (\secref{THUNK_SELECTOR}) use the closure
1418 layout field to hold the selector index, since the layout is always
1419 known (the closure contains a single pointer field).
1422 \item A one-word {\em Static Reference Table} field. This field
1423 points to the static reference table for the closure (\secref{srt}),
1424 and is only present for the following closure types:
1432 \item \emph{Profiling info\/}
1434 \ToDo{The profiling info is completely bogus. I've not deleted it
1435 from the document but I've commented it all out.}
1437 % change to \iftrue to uncomment this section
1440 Closure category records are attached to the info table of the
1441 closure. They are declared with the info table. We put pointers to
1442 these ClCat things in info tables. We need these ClCat things because
1443 they are mutable, whereas info tables are immutable. Hashing will map
1444 similar categories to the same hash value allowing statistics to be
1445 grouped by closure category.
1447 Cost Centres and Closure Categories are hashed to provide indexes
1448 against which arbitrary information can be stored. These indexes are
1449 memoised in the appropriate cost centre or category record and
1450 subsequent hashes avoided by the index routine (it simply returns the
1453 There are different features which can be hashed allowing information
1454 to be stored for different groupings. Cost centres have the cost
1455 centre recorded (using the pointer), module and group. Closure
1456 categories have the closure description and the type
1457 description. Records with the same feature will be hashed to the same
1460 The initialisation routines, @init_index_<feature>@, allocate a hash
1461 table in which the cost centre / category records are stored. The
1462 lower bound for the table size is taken from @max_<feature>_no@. They
1463 return the actual table size used (the next power of 2). Unused
1464 locations in the hash table are indicated by a 0 entry. Successive
1465 @init_index_<feature>@ calls just return the actual table size.
1467 Calls to @index_<feature>@ will insert the cost centre / category
1468 record in the @<feature>@ hash table, if not already inserted. The hash
1469 index is memoised in the record and returned.
1471 CURRENTLY ONLY ONE MEMOISATION SLOT IS AVILABLE IN EACH RECORD SO
1472 HASHING CAN ONLY BE DONE ON ONE FEATURE FOR EACH RECORD. This can be
1473 easily relaxed at the expense of extra memoisation space or continued
1476 The initialisation routines must be called before initialisation of
1477 the stacks and heap as they require to allocate storage. It is also
1478 expected that the caller may want to allocate additional storage in
1479 which to store profiling information based on the return table size
1483 \begin{tabular}{|l|}
1487 \\ \hline Description String
1488 \\ \hline Type String
1494 \item[Hash Index] Memoised copy
1496 Is this category selected (-1 == not memoised, selected? 0 or 1)
1498 One of the following values (defined in CostCentre.lh):
1506 A partial application.
1508 A thunk, or suspension.
1513 \item[@ForeignObj_K@]
1514 A Foreign object (non-Haskell heap resident).
1516 The Stable Pointer table. (There should only be one of these but it
1517 represents a form of weak space leak since it can't shrink to meet
1518 non-demand so it may be worth watching separately? ADR)
1519 \item[@INTERNAL_KIND@]
1520 Something internal to the runtime system.
1524 \item[Description] Source derived string detailing closure description.
1525 \item[Type] Source derived string detailing closure type.
1528 \fi % end of commented out stuff
1530 \item \emph{Parallelism info\/}
1533 \item \emph{Debugging info\/}
1539 %-----------------------------------------------------------------------------
1540 \Subsection{Kinds of Heap Object}{closures}
1542 Heap objects can be classified in several ways, but one useful one is
1546 \emph{Static closures} occupy fixed, statically-allocated memory
1547 locations, with globally known addresses.
1550 \emph{Dynamic closures} are individually allocated in the heap.
1553 \emph{Stack closures} are closures allocated within a thread's stack
1554 (which is itself a heap object). Unlike other closures, there are
1555 never any pointers to stack closures. Stack closures are discussed in
1559 A second useful classification is this:
1562 \item \emph{Executive objects}, such as thunks and data constructors,
1563 participate directly in a program's execution. They can be subdivided
1564 into three kinds of objects according to their type: \begin{itemize}
1566 \item \emph{Pointed objects}, represent values of a \emph{pointed}
1567 type (<.pointed types launchbury.>) --i.e.~a type that includes
1568 $\bottom$ such as @Int@ or @Int# -> Int#@.
1570 \item \emph{Unpointed objects}, represent values of a \emph{unpointed}
1571 type --i.e.~a type that does not include $\bottom$ such as @Int#@ or
1574 \item \emph{Activation frames}, represent ``continuations''. They are
1575 always stored on the stack and are never pointed to by heap objects or
1576 passed as arguments. \note{It's not clear if this will still be true
1577 once we support speculative evaluation.}
1581 \item \emph{Administrative objects}, such as stack objects and thread
1582 state objects, do not represent values in the original program.
1585 Only pointed objects can be entered. If an unpointed object is
1586 entered the program will usually terminate with a fatal error.
1588 This section enumerates all the kinds of heap objects in the system.
1589 Each is identified by a distinct closure type field in its info table.
1591 \begin{tabular}{|l|l|l|l|l|l|l|l|l|l|l|}
1594 closure type & Section \\
1600 @CONSTR@ & \ref{sec:CONSTR} \\
1601 @CONSTR_p_n@ & \ref{sec:CONSTR} \\
1602 @CONSTR_STATIC@ & \ref{sec:CONSTR} \\
1603 @CONSTR_NOCAF_STATIC@ & \ref{sec:CONSTR} \\
1605 @FUN@ & \ref{sec:FUN} \\
1606 @FUN_p_n@ & \ref{sec:FUN} \\
1607 @FUN_STATIC@ & \ref{sec:FUN} \\
1609 @THUNK@ & \ref{sec:THUNK} \\
1610 @THUNK_p_n@ & \ref{sec:THUNK} \\
1611 @THUNK_STATIC@ & \ref{sec:THUNK} \\
1612 @THUNK_SELECTOR@ & \ref{sec:THUNK_SELECTOR} \\
1614 @BCO@ & \ref{sec:BCO} \\
1616 @AP_UPD@ & \ref{sec:AP_UPD} \\
1617 @PAP@ & \ref{sec:PAP} \\
1619 @IND@ & \ref{sec:IND} \\
1620 @IND_OLDGEN@ & \ref{sec:IND} \\
1621 @IND_PERM@ & \ref{sec:IND} \\
1622 @IND_OLDGEN_PERM@ & \ref{sec:IND} \\
1623 @IND_STATIC@ & \ref{sec:IND} \\
1625 @CAF_UNENTERED@ & \ref{sec:CAF} \\
1626 @CAF_ENTERED@ & \ref{sec:CAF} \\
1627 @CAF_BLACKHOLE@ & \ref{sec:CAF} \\
1633 @BLACKHOLE@ & \ref{sec:BLACKHOLE} \\
1634 @BLACKHOLE_BQ@ & \ref{sec:BLACKHOLE_BQ} \\
1636 @MVAR@ & \ref{sec:MVAR} \\
1638 @ARR_WORDS@ & \ref{sec:ARR_WORDS} \\
1640 @MUTARR_PTRS@ & \ref{sec:MUT_ARR_PTRS} \\
1641 @MUTARR_PTRS_FROZEN@ & \ref{sec:MUT_ARR_PTRS_FROZEN} \\
1643 @MUT_VAR@ & \ref{sec:MUT_VAR} \\
1645 @WEAK@ & \ref{sec:WEAK} \\
1646 @FOREIGN@ & \ref{sec:FOREIGN} \\
1647 @STABLE_NAME@ & \ref{sec:STABLE_NAME} \\
1651 Activation frames do not live (directly) on the heap --- but they have
1652 a similar organisation.
1654 \begin{tabular}{|l|l|}\hline
1655 closure type & Section \\ \hline
1656 @RET_SMALL@ & \ref{sec:activation-records} \\
1657 @RET_VEC_SMALL@ & \ref{sec:activation-records} \\
1658 @RET_BIG@ & \ref{sec:activation-records} \\
1659 @RET_VEC_BIG@ & \ref{sec:activation-records} \\
1660 @UPDATE_FRAME@ & \ref{sec:activation-records} \\
1661 @CATCH_FRAME@ & \ref{sec:activation-records} \\
1662 @SEQ_FRAME@ & \ref{sec:activation-records} \\
1663 @STOP_FRAME@ & \ref{sec:activation-records} \\
1667 There are also a number of administrative objects. It is an error to
1668 enter one of these objects.
1670 \begin{tabular}{|l|l|}\hline
1671 closure type & Section \\ \hline
1672 @TSO@ & \ref{sec:TSO} \\
1673 @SPARK_OBJECT@ & \ref{sec:SPARK} \\
1674 @BLOCKED_FETCH@ & \ref{sec:BLOCKED_FETCH} \\
1675 @FETCHME@ & \ref{sec:FETCHME} \\
1679 \Subsection{Predicates}{closure-predicates}
1681 The runtime system sometimes needs to be able to distinguish objects
1682 according to their properties: is the object updateable? is it in weak
1683 head normal form? etc. These questions can be answered by examining
1684 the closure type field of the object's info table.
1686 We define the following predicates to detect families of related
1687 info types. They are mutually exclusive and exhaustive.
1690 \item @isCONSTR@ is true for @CONSTR@s.
1691 \item @isFUN@ is true for @FUN@s.
1692 \item @isTHUNK@ is true for @THUNK@s.
1693 \item @isBCO@ is true for @BCO@s.
1694 \item @isAP@ is true for @AP@s.
1695 \item @isPAP@ is true for @PAP@s.
1696 \item @isINDIRECTION@ is true for indirection objects.
1697 \item @isBH@ is true for black holes.
1698 \item @isFOREIGN_OBJECT@ is true for foreign objects.
1699 \item @isARRAY@ is true for array objects.
1700 \item @isMVAR@ is true for @MVAR@s.
1701 \item @isIVAR@ is true for @IVAR@s.
1702 \item @isFETCHME@ is true for @FETCHME@s.
1703 \item @isSLOP@ is true for slop objects.
1704 \item @isRET_ADDR@ is true for return addresses.
1705 \item @isUPD_ADDR@ is true for update frames.
1706 \item @isTSO@ is true for @TSO@s.
1707 \item @isSTABLE_PTR_TABLE@ is true for the stable pointer table.
1708 \item @isSPARK_OBJECT@ is true for spark objects.
1709 \item @isBLOCKED_FETCH@ is true for blocked fetch objects.
1710 \item @isINVALID_INFOTYPE@ is true for all other info types.
1714 The following predicates detect other interesting properties:
1718 \item @isPOINTED@ is true if an object has a pointed type.
1720 If an object is pointed, the following predicates may be true
1721 (otherwise they are false). @isWHNF@ and @isUPDATEABLE@ are
1725 \item @isWHNF@ is true if the object is in Weak Head Normal Form.
1726 Note that unpointed objects are (arbitrarily) not considered to be in WHNF.
1728 @isWHNF@ is true for @PAP@s, @CONSTR@s, @FUN@s and all @BCO@s.
1730 \ToDo{Need to distinguish between whnf BCOs and non-whnf BCOs in their
1733 \item @isUPDATEABLE@ is true if the object may be overwritten with an
1736 @isUPDATEABLE@ is true for @THUNK@s, @AP@s and @BH@s.
1740 It is possible for a pointed object to be neither updatable nor in
1741 WHNF. For example, indirections.
1743 \item @isUNPOINTED@ is true if an object has an unpointed type.
1744 All such objects are boxed since only boxed objects have info pointers.
1746 It is true for @ARR_WORDS@, @ARR_PTRS@, @MUTVAR@, @MUTARR_PTRS@,
1747 @MUTARR_PTRS_FROZEN@, @FOREIGN@ objects, @MVAR@s and @IVAR@s.
1749 \item @isACTIVATION_FRAME@ is true for activation frames of all sorts.
1751 It is true for return addresses and update frames.
1753 \item @isVECTORED_RETADDR@ is true for vectored return addresses.
1754 \item @isDIRECT_RETADDR@ is true for direct return addresses.
1757 \item @isADMINISTRATIVE@ is true for administrative objects:
1758 @TSO@s, the stable pointer table, spark objects and blocked fetches.
1760 \item @hasSRT@ is true if the info table for the object contains an
1763 @hasSRT@ is true for @THUNK@s, @FUN@s, and @RET@s.
1769 \item @isSTATIC@ is true for any statically allocated closure.
1771 \item @isMUTABLE@ is true for objects with mutable pointer fields:
1772 @MUT_ARR@s, @MUTVAR@s, @MVAR@s and @IVAR@s.
1774 \item @isSparkable@ is true if the object can (and should) be sparked.
1775 It is true of updateable objects which are not in WHNF with the
1776 exception of @THUNK_SELECTOR@s and black holes.
1780 As a minor optimisation, we might use the top bits of the @INFO_TYPE@
1781 field to ``cache'' the answers to some of these predicates.
1783 An indirection either points to HNF (post update); or is result of
1784 overwriting a FetchMe, in which case the thing fetched is either under
1785 evaluation (BLACKHOLE), or by now an HNF. Thus, indirections get
1788 \subsection{Closures (aka Pointed Objects)}
1790 An object can be entered iff it is a closure.
1792 \Subsubsection{Function closures}{FUN}
1794 Function closures represent lambda abstractions. For example,
1795 consider the top-level declaration:
1797 f = \x -> let g = \y -> x+y
1800 Both @f@ and @g@ are represented by function closures. The closure
1801 for @f@ is \emph{static} while that for @g@ is \emph{dynamic}.
1803 The layout of a function closure is as follows:
1805 \begin{tabular}{|l|l|l|l|}\hline
1806 \emph{Fixed header} & \emph{Pointers} & \emph{Non-pointers} \\ \hline
1810 The data words (pointers and non-pointers) are the free variables of
1811 the function closure. The number of pointers and number of
1812 non-pointers are stored in @info->layout.ptrs@ and
1813 @info->layout.nptrs@ respecively.
1815 There are several different sorts of function closure, distinguished
1816 by their closure type field:
1820 \item @FUN@: a vanilla, dynamically allocated on the heap.
1822 \item $@FUN_@p@_@np$: to speed up garbage collection a number of
1823 specialised forms of @FUN@ are provided, for particular $(p,np)$
1824 pairs, where $p$ is the number of pointers and $np$ the number of
1827 \item @FUN_STATIC@. Top-level, static, function closures (such as @f@
1828 above) have a different layout than dynamic ones:
1831 \begin{tabular}{|l|l|l|}\hline
1832 \emph{Fixed header} & \emph{Static object link} \\ \hline
1836 Static function closures have no free variables. (However they may
1837 refer to other static closures; these references are recorded in the
1838 function closure's SRT.) They have one field that is not present in
1839 dynamic closures, the \emph{static object link} field. This is used
1840 by the garbage collector in the same way that to-space is, to gather
1841 closures that have been determined to be live but that have not yet
1844 \note{Static function closures that have no static references, and
1845 hence a null SRT pointer, don't need the static object link field. We
1846 don't take advantage of this at the moment, but we could. See
1847 @CONSTR_NOCAF_STATIC@.}
1850 Each lambda abstraction, $f$, in the STG program has its own private
1851 info table. The following labels are relevant:
1855 \item $f$@_info@ is $f$'s info table.
1857 \item $f$@_entry@ is $f$'s slow entry point (i.e. the entry code of
1858 its info table; so it will label the same byte as $f$@_info@).
1860 \item $f@_fast_@k$ is $f$'s fast entry point. $k$ is the number of
1861 arguments $f$ takes; encoding this number in the fast-entry label
1862 occasionally catches some nasty code-generation errors.
1866 \Subsubsection{Data constructors}{CONSTR}
1868 Data-constructor closures represent values constructed with algebraic
1869 data type constructors. The general layout of data constructors is
1870 the same as that for function closures. That is
1873 \begin{tabular}{|l|l|l|l|}\hline
1874 \emph{Fixed header} & \emph{Pointers} & \emph{Non-pointers} \\ \hline
1878 There are several different sorts of constructor:
1882 \item @CONSTR@: a vanilla, dynamically allocated constructor.
1884 \item @CONSTR_@$p$@_@$np$: just like $@FUN_@p@_@np$.
1886 \item @CONSTR_INTLIKE@. A dynamically-allocated heap object that
1887 looks just like an @Int@. The garbage collector checks to see if it
1888 can common it up with one of a fixed set of static int-like closures,
1889 thus getting it out of the dynamic heap altogether.
1891 \item @CONSTR_CHARLIKE@: same deal, but for @Char@.
1893 \item @CONSTR_STATIC@ is similar to @FUN_STATIC@, with the
1894 complication that the layout of the constructor must mimic that of a
1895 dynamic constructor, because a static constructor might be returned to
1896 some code that unpacks it. So its layout is like this:
1899 \begin{tabular}{|l|l|l|l|l|}\hline
1900 \emph{Fixed header} & \emph{Pointers} & \emph{Non-pointers} & \emph{Static object link}\\ \hline
1904 The static object link, at the end of the closure, serves the same purpose
1905 as that for @FUN_STATIC@. The pointers in the static constructor can point
1906 only to other static closures.
1908 The static object link occurs last in the closure so that static
1909 constructors can store their data fields in exactly the same place as
1910 dynamic constructors.
1912 \item @CONSTR_NOCAF_STATIC@. A statically allocated data constructor
1913 that guarantees not to point (directly or indirectly) to any CAF
1914 (\secref{CAF}). This means it does not need a static object
1915 link field. Since we expect that there might be quite a lot of static
1916 constructors this optimisation makes sense. Furthermore, the @NOCAF@
1917 tag allows the compiler to indicate that no CAFs can be reached
1918 anywhere \emph{even indirectly}.
1922 For each data constructor $Con$, two info tables are generated:
1925 \item $Con$@_con_info@ labels $Con$'s dynamic info table,
1926 shared by all dynamic instances of the constructor.
1927 \item $Con$@_static@ labels $Con$'s static info table,
1928 shared by all static instances of the constructor.
1931 Each constructor also has a \emph{constructor function}, which is a
1932 curried function which builds an instance of the constructor. The
1933 constructor function has an info table labelled as @$Con$_info@, and
1934 entry code pointed to by @$Con$_entry@.
1936 Nullary constructors are represented by a single static info table,
1937 which everyone points to. Thus for a nullary constructor we can omit
1938 the dynamic info table and the constructor function.
1940 \subsubsection{Thunks}
1942 \label{sec:THUNK_SELECTOR}
1944 A thunk represents an expression that is not obviously in head normal
1945 form. For example, consider the following top-level definitions:
1947 range = between 1 10
1948 f = \x -> let ys = take x range
1951 Here the right-hand sides of @range@ and @ys@ are both thunks; the former
1952 is static while the latter is dynamic.
1954 The layout of a thunk is the same as that for a function closure.
1955 However, thunks must have a payload of at least @MIN_UPD_SIZE@
1956 words to allow it to be overwritten with a black hole and an
1957 indirection. The compiler may have to add extra non-pointer fields to
1958 satisfy this constraint.
1961 \begin{tabular}{|l|l|l|l|l|}\hline
1962 \emph{Fixed header} & \emph{Pointers} & \emph{Non-pointers} \\ \hline
1966 The layout word in the info table contains the same information as for
1967 function closures; that is, number of pointers and number of
1970 A thunk differs from a function closure in that it can be updated.
1972 There are several forms of thunk:
1976 \item @THUNK@ and $@THUNK_@p@_@np$: vanilla, dynamically allocated
1977 thunks. Dynamic thunks are overwritten with normal indirections
1978 (@IND@), or old generation indirections (@IND_OLDGEN@): see
1981 \item @THUNK_STATIC@. A static thunk is also known as a
1982 \emph{constant applicative form}, or \emph{CAF}. Static thunks are
1983 overwritten with static indirections.
1986 \begin{tabular}{|l|l|}\hline
1987 \emph{Fixed header} & \emph{Static object link}\\ \hline
1991 \item @THUNK_SELECTOR@ is a (dynamically allocated) thunk whose entry
1992 code performs a simple selection operation from a data constructor
1993 drawn from a single-constructor type. For example, the thunk
1995 x = case y of (a,b) -> a
1997 is a selector thunk. A selector thunk is laid out like this:
2000 \begin{tabular}{|l|l|l|l|}\hline
2001 \emph{Fixed header} & \emph{Selectee pointer} \\ \hline
2005 The layout word contains the byte offset of the desired word in the
2006 selectee. Note that this is different from all other thunks.
2008 The garbage collector ``peeks'' at the selectee's tag (in its info
2009 table). If it is evaluated, then it goes ahead and does the
2010 selection, and then behaves just as if the selector thunk was an
2011 indirection to the selected field. If it is not evaluated, it treats
2012 the selector thunk like any other thunk of that shape.
2013 [Implementation notes. Copying: only the evacuate routine needs to be
2014 special. Compacting: only the PRStart (marking) routine needs to be
2017 There is a fixed set of pre-compiled selector thunks built into the
2018 RTS, representing offsets from 0 to @MAX_SPEC_SELECTOR_THUNK@. The
2019 info tables are labelled @sel_info_$n$@ where $n$ is the offset.
2023 The only label associated with a thunk is its info table:
2026 \item[$f$@_info@] is $f$'s info table.
2030 \Subsubsection{Byte-code objects}{BCO}
2032 A Byte-Code Object (BCO) is a container for a a chunk of byte-code,
2033 which can be executed by Hugs. The byte-code represents a
2034 supercombinator in the program: when Hugs compiles a module, it
2035 performs lambda lifting and each resulting supercombinator becomes a
2036 byte-code object in the heap.
2038 BCOs are not updateable; the bytecode compiler represents updatable
2039 thunks using a combination of @AP@s and @BCO@s.
2041 The semantics of BCOs are described in \secref{hugs-heap-objects}. A
2042 BCO has the following structure:
2045 \begin{tabular}{|l|l|l|l|l|l|}
2047 \emph{Fixed Header} & \emph{Layout} & \emph{Offset} & \emph{Size} &
2048 \emph{Literals} & \emph{Byte code} \\
2055 \item The entry code is a static code fragment/info table that returns
2056 to the scheduler to invoke Hugs (\secref{ghc-to-hugs-switch}).
2057 \item \emph{Layout} contains the number of pointer literals in the
2058 \emph{Literals} field.
2059 \item \emph{Offset} is the offset to the byte code from the start of
2061 \item \emph{Size} is the number of words of byte code in the object.
2062 \item \emph{Literals} contains any pointer and non-pointer literals used in
2063 the byte-codes (including jump addresses), pointers first.
2064 \item \emph{Byte code} contains \emph{Size} words of non-pointer byte
2069 \Subsubsection{Partial applications}{PAP}
2071 A partial application (PAP) represents a function applied to too few
2072 arguments. It is only built as a result of updating after an
2073 argument-satisfaction check failure. A PAP has the following shape:
2076 \begin{tabular}{|l|l|l|l|}\hline
2077 \emph{Fixed header} & \emph{No of words of stack} & \emph{Function closure} & \emph{Stack chunk ...} \\ \hline
2081 The ``Stack chunk'' is a copy of the chunk of stack above the update
2082 frame; ``No of words of stack'' tells how many words it consists of.
2083 The function closure is (a pointer to) the closure for the function
2084 whose argument-satisfaction check failed.
2086 In the normal case where a PAP is built as a result of an argument
2087 satisfaction check failure, the stack chunk will just contain
2088 ``pending arguments'', ie. pointers and tagged non-pointers. It may
2089 in fact also contain activation records, but not update frames, seq
2090 frames, or catch frames. The reason is the garbage collector uses the
2091 same code to scavenge a stack as it does to scavenge the payload of a
2092 PAP, but an update frame contains a link to the next update frame in
2093 the chain and this link would need to be relocated during garbage
2094 collection. Revertible black holes and asynchronous exceptions use
2095 the more general form of PAPs (see Section \ref{revertible-bh}).
2097 There is just one standard form of PAP. There is just one info table
2098 too, called @PAP_info@. Its entry code simply copies the arg stack
2099 chunk back on top of the stack and enters the function closure. (It
2100 has to do a stack overflow test first.)
2102 There is just one way to build a PAP: by calling @stg_update_PAP@ with
2103 the function closure in register @R1@ and the pending arguments on the
2104 stack. The @stg_update_PAP@ function will build the PAP, perform the
2105 update, and return to the next activation record on the stack. If
2106 there are \emph{no} pending arguments on the stack, then no PAP need
2107 be built: in this case @stg_update_PAP@ just overwrites the updatee
2108 with an indirection to the function closure.
2110 PAPs are also used to implement Hugs functions (where the arguments
2111 are free variables). PAPs generated by Hugs can be static so we need
2112 both @PAP@ and @PAP_STATIC@.
2114 \Subsubsection{@AP_UPD@ objects}{AP_UPD}
2116 @AP_UPD@ objects are used to represent thunks built by Hugs. The only
2117 distintion between an @AP_UPD@ and a @PAP@ is that an @AP_UPD@ is
2121 \begin{tabular}{|l|l|l|l|}
2123 \emph{Fixed Header} & \emph{No of stack words} & \emph{Function closure} & \emph{Stack chunk} \\
2128 The entry code pushes an update frame, copies the arg stack chunk on
2129 top of the stack, and enters the function closure. (It has to do a
2130 stack overflow test first.)
2132 The ``stack chunk'' is a block of stack not containing update frames,
2133 seq frames or catch frames (just like a PAP). In the case of Hugs,
2134 the stack chunk will contain the free variables of the thunk, and the
2135 function closure is (a pointer to) the closure for the thunk. The
2136 argument stack may be empty if the thunk has no free variables.
2138 \note{Since @AP_UPD@s are updateable, the @MIN_UPD_SIZE@ constraint
2141 \Subsubsection{Indirections}{IND}
2143 Indirection closures just point to other closures. They are introduced
2144 when a thunk is updated to point to its value. The entry code for all
2145 indirections simply enters the closure it points to.
2147 There are several forms of indirection:
2150 \item[@IND@] is the vanilla, dynamically-allocated indirection.
2151 It is removed by the garbage collector. It has the following
2154 \begin{tabular}{|l|l|l|}\hline
2155 \emph{Fixed header} & \emph{Target closure} \\ \hline
2159 An @IND@ only exists in the youngest generation. In older
2160 generations, we have @IND_OLDGEN@s. The update code
2161 (@Upd_frame_$n$_entry@) checks whether the updatee is in the youngest
2162 generation before deciding which kind of indirection to use.
2164 \item[@IND_OLDGEN@] is the vanilla, dynamically-allocated indirection.
2165 It is removed by the garbage collector. It has the following
2168 \begin{tabular}{|l|l|l|}\hline
2169 \emph{Fixed header} & \emph{Target closure} & \emph{Mutable link field} \\ \hline
2172 It contains a \emph{mutable link field} that is used to string together
2173 mutable objects in each old generation.
2176 for lexical profiling, it is necessary to maintain cost centre
2177 information in an indirection, so ``permanent indirections'' are
2178 retained forever. Otherwise they are just like vanilla indirections.
2179 \note{If a permanent indirection points to another permanent
2180 indirection or a @CONST@ closure, it is possible to elide the indirection
2181 since it will have no effect on the profiler.}
2183 \note{Do we still need @IND@ in the profiling build, or do we just
2184 need @IND@ but its behaviour changes when profiling is on?}
2186 \item[@IND_OLDGEN_PERM@]
2187 Just like an @IND_OLDGEN@, but sticks around like an @IND_PERM@.
2189 \item[@IND_STATIC@] is used for overwriting CAFs when they have been
2190 evaluated. Static indirections are not removed by the garbage
2191 collector; and are statically allocated outside the heap (and should
2192 stay there). Their static object link field is used just as for
2193 @FUN_STATIC@ closures.
2196 \begin{tabular}{|l|l|l|}
2198 \emph{Fixed header} & \emph{Target closure} & \emph{Static link field} \\
2205 \subsubsection{Black holes and blocking queues}
2206 \label{sec:BLACKHOLE}
2207 \label{sec:BLACKHOLE_BQ}
2209 Black hole closures are used to overwrite closures currently being
2210 evaluated. They inform the garbage collector that there are no live
2211 roots in the closure, thus removing a potential space leak.
2213 Black holes also become synchronization points in the concurrent
2214 world. When a thread attempts to enter a blackhole, it must wait for
2215 the result of the computation, which is presumably in progress in
2218 \note{In a single-threaded system, entering a black hole indicates an
2219 infinite loop. In a concurrent system, entering a black hole
2220 indicates an infinite loop only if the hole is being entered by the
2221 same thread that originally entered the closure. It could also bring
2222 about a deadlock situation where several threads are waiting
2223 circularly on computations in progress.}
2225 There are two types of black hole:
2230 A straightforward blackhole just consists of an info pointer and some
2231 padding to allow updating with an @IND_OLDGEN@ if necessary. This
2232 type of blackhole has no waiting threads.
2235 \begin{tabular}{|l|l|l|}
2237 \emph{Fixed header} & \emph{Padding} & \emph{Padding} \\
2242 If we're doing \emph{eager blackholing} then a thunk's info pointer is
2243 overwritten with @BLACKHOLE_info@ at the time of entry; hence the need
2244 for blackholes to be small, otherwise we'd be overwriting part of the
2247 \item[@BLACKHOLE_BQ@]
2248 When a thread enters a @BLACKHOLE@, it is turned into a @BLACKHOLE_BQ@
2249 (blocking queue), which contains a linked list of blocked threads in
2250 addition to the info pointer.
2253 \begin{tabular}{|l|l|l|}
2255 \emph{Fixed header} & \emph{Blocked thread link} & \emph{Mutable link field} \\
2260 The \emph{Blocked thread link} points to the TSO of the first thread
2261 waiting for the value of this thunk. All subsequent TSOs in the list
2262 are linked together using their @tso->link@ field, ending in
2263 @END_TSO_QUEUE_closure@.
2265 Because new threads can be added to the \emph{Blocked thread link}, a
2266 blocking queue is \emph{mutable}, so we need a mutable link field in
2267 order to chain it on to a mutable list for the generational garbage
2272 \Subsubsection{FetchMes}{FETCHME}
2274 In the parallel systems, FetchMes are used to represent pointers into
2275 the global heap. When evaluated, the value they point to is read from
2278 \ToDo{Describe layout}
2280 Because there may be offsets into these arrays, a primitive array
2281 cannot be handled as a FetchMe in the parallel system, but must be
2282 shipped in its entirety if its parent closure is shipped.
2286 \Subsection{Unpointed Objects}{unpointed-objects}
2288 A variable of unpointed type is always bound to a \emph{value}, never
2289 to a \emph{thunk}. For this reason, unpointed objects cannot be
2292 \subsubsection{Immutable objects}
2293 \label{sec:ARR_WORDS}
2296 \item[@ARR_WORDS@] is a variable-sized object consisting solely of
2297 non-pointers. It is used for arrays of all sorts of things (bytes,
2298 words, floats, doubles... it doesn't matter).
2300 Strictly speaking, an @ARR_WORDS@ could be mutable, but because it
2301 only contains non-pointers we don't need to track this fact.
2304 \begin{tabular}{|c|c|c|c|}
2306 \emph{Fixed Hdr} & \emph{No of non-pointers} & \emph{Non-pointers\ldots} \\ \hline
2311 \subsubsection{Mutable objects}
2312 \label{sec:mutables}
2314 \label{sec:MUT_ARR_PTRS}
2315 \label{sec:MUT_ARR_PTRS_FROZEN}
2318 Some of these objects are \emph{mutable}; they represent objects which
2319 are explicitly mutated by Haskell code through the @ST@ or @IO@
2320 monads. They're not used for thunks which are updated precisely once.
2321 Depending on the garbage collector, mutable closures may contain extra
2322 header information which allows a generational collector to implement
2323 the ``write barrier.''
2325 Notice that mutable objects all have the same general layout: there is
2326 a mutable link field as the second word after the header. This is so
2327 that code to process old-generation mutable lists doesn't need to look
2328 at the type of the object to determine where its link field is.
2332 \item[@MUT_VAR@] is a mutable variable.
2334 \begin{tabular}{|c|c|c|}
2336 \emph{Fixed Hdr} \emph{Pointer} & \emph{Mutable link} & \\ \hline
2340 \item[@MUT_ARR_PTRS@] is a mutable array of pointers. Such an array
2341 may be \emph{frozen}, becoming an @MUT_ARR_PTRS_FROZEN@, with a
2342 different info-table.
2345 \begin{tabular}{|c|c|c|c|}
2347 \emph{Fixed Hdr} & \emph{No of ptrs} & \emph{Mutable link} & \emph{Pointers\ldots} \\ \hline
2351 \item[@MUT_ARR_PTRS_FROZEN@] This is the immutable version of
2352 @MUT_ARR_PTRS@. It still has a mutable link field for two reasons: we
2353 need to keep it on the mutable list for an old generation at least
2354 until the next garbage collection, and it may become mutable again via
2358 \begin{tabular}{|c|c|c|c|}
2360 \emph{Fixed Hdr} & \emph{No of ptrs} & \emph{Mutable link} & \emph{Pointers\ldots} \\ \hline
2367 \begin{tabular}{|l|l|l|l|l|}
2369 \emph{Fixed header} & \emph{Head} & \emph{Mutable link} & \emph{Tail}
2380 \Subsubsection{Foreign objects}{FOREIGN}
2382 Here's what a ForeignObj looks like:
2385 \begin{tabular}{|l|l|l|l|}
2387 \emph{Fixed header} & \emph{Data} \\
2392 A foreign object is simple a boxed pointer to an address outside the
2393 Haskell heap, possible to @malloc@ed data. The only reason foreign
2394 objects exist is so that we can track the lifetime of one using weak
2395 pointers (see \secref{WEAK}) and run a finaliser when the foreign
2396 object is unreachable.
2398 \subsubsection{Weak pointers}
2402 \begin{tabular}{|l|l|l|l|l|}
2404 \emph{Fixed header} & \emph{Key} & \emph{Value} & \emph{Finaliser}
2410 \ToDo{Weak poitners}
2412 \subsubsection{Stable names}
2413 \label{sec:STABLE_NAME}
2416 \begin{tabular}{|l|l|l|l|}
2418 \emph{Fixed header} & \emph{Index} \\
2425 The remaining objects types are all administrative --- none of them
2428 \subsection{Other weird objects}
2430 \label{sec:BLOCKED_FETCH}
2433 \item[@BlockedFetch@ heap objects (`closures')] (parallel only)
2435 @BlockedFetch@s are inbound fetch messages blocked on local closures.
2436 They arise as entries in a local blocking queue when a fetch has been
2437 received for a local black hole. When awakened, we look at their
2438 contents to figure out where to send a resume.
2440 A @BlockedFetch@ closure has the form:
2442 \begin{tabular}{|l|l|l|l|l|l|}\hline
2443 \emph{Fixed header} & link & node & gtid & slot & weight \\ \hline
2447 \item[Spark Closures] (parallel only)
2449 Spark closures are used to link together all closures in the spark pool. When
2450 the current processor is idle, it may choose to speculatively evaluate some of
2451 the closures in the pool. It may also choose to delete sparks from the pool.
2453 \begin{tabular}{|l|l|l|l|l|l|}\hline
2454 \emph{Fixed header} & \emph{Spark pool link} & \emph{Sparked closure} \\ \hline
2458 \item[Slop Objects]\label{sec:slop-objects}
2460 Slop objects are used to overwrite the end of an updatee if it is
2461 larger than an indirection. Normal slop objects consist of an info
2462 pointer a size word and a number of slop words.
2465 \begin{tabular}{|l|l|l|l|l|l|}\hline
2466 \emph{Info Pointer} & \emph{Size} & \emph{Slop Words} \\ \hline
2470 This is too large for single word slop objects which consist of a
2473 Note that slop objects only contain an info pointer, not a standard
2474 fixed header. This doesn't cause problems because slop objects are
2475 always unreachable --- they can only be accessed by linearly scanning
2478 \note{Currently we don't use slop objects because the storage manager
2479 isn't reliant on objects being adjacent, but if we move to a ``mostly
2480 copying'' style collector, this will become an issue.}
2484 \Subsection{Thread State Objects (TSOs)}{TSO}
2486 In the multi-threaded system, the state of a suspended thread is
2487 packed up into a Thread State Object (TSO) which contains all the
2488 information needed to restart the thread and for the garbage collector
2489 to find all reachable objects. When a thread is running, it may be
2490 ``unpacked'' into machine registers and various other memory locations
2491 to provide faster access.
2493 Single-threaded systems don't really \emph{need\/} TSOs --- but they do
2494 need some way to tell the storage manager about live roots so it is
2495 convenient to use a single TSO to store the mutator state even in
2496 single-threaded systems.
2498 Rather than manage TSOs' alloc/dealloc, etc., in some \emph{ad hoc}
2499 way, we instead alloc/dealloc/etc them in the heap; then we can use
2500 all the standard garbage-collection/fetching/flushing/etc machinery on
2501 them. So that's why TSOs are ``heap objects,'' albeit very special
2504 \begin{tabular}{|l|l|}
2505 \hline \emph{Fixed header}
2506 \\ \hline \emph{Link field}
2507 \\ \hline \emph{Mutable link field}
2508 \\ \hline \emph{What next}
2509 \\ \hline \emph{State}
2510 \\ \hline \emph{Thread Id}
2511 \\ \hline \emph{Exception Handlers}
2512 \\ \hline \emph{Ticky Info}
2513 \\ \hline \emph{Profiling Info}
2514 \\ \hline \emph{Parallel Info}
2515 \\ \hline \emph{GranSim Info}
2516 \\ \hline \emph{Stack size}
2517 \\ \hline \emph{Max Stack size}
2520 \\ \hline \emph{SpLim}
2528 The contents of a TSO are:
2531 \item[\emph{Link field}] This is a pointer used to maintain a list of
2532 threads with a similar state (e.g.~all runnable, all sleeping, all
2533 blocked on the same black hole, all blocked on the same MVar,
2536 \item[\emph{Mutable link field}] Because the stack is mutable by
2537 definition, the generational collector needs to track TSOs in older
2538 generations that may point into younger ones (which is just about any
2539 TSO for a thread that has run recently). Hence the need for a mutable
2540 link field (see \secref{mutables}).
2542 \item[\emph{What next}]
2543 This field has five values:
2545 \item[@ThreadEnterGHC@] The thread can be started by entering the
2546 closure pointed to by the word on the top of the stack.
2547 \item[@ThreadRunGHC@] The thread can be started by jumping to the
2548 address on the top of the stack.
2549 \item[@ThreadEnterHugs@] The stack has a pointer to a Hugs-built
2550 closure on top of the stack: enter the closure to run the thread.
2551 \item[@ThreadKilled@] The thread has been killed (by @killThread#@).
2552 It is probably still around because it is on some queue somewhere and
2553 hasn't been garbage collected yet.
2554 \item[@ThreadComplete@] The thread has finished. Its @TSO@ hasn't
2555 been garbage collected yet.
2558 \item[\emph{Thread Id}]
2559 This field contains a (not necessarily unique) integer that identifies
2560 the thread. It can be used eg. for hashing.
2562 \item[\emph{Ticky Info}] Optional information for ``Ticky Ticky''
2563 statistics: @TSO_STK_HWM@ is the maximum number of words allocated to
2566 \item[\emph{Profiling Info}] Optional information for profiling:
2567 @TSO_CCC@ is the current cost centre.
2569 \item[\emph{Parallel Info}]
2570 Optional information for parallel execution.
2574 % \item The types of threads (@TSO_TYPE@):
2575 % \begin{description}
2576 % \item[@T_MAIN@] Must be executed locally.
2577 % \item[@T_REQUIRED@] A required thread -- may be exported.
2578 % \item[@T_ADVISORY@] An advisory thread -- may be exported.
2579 % \item[@T_FAIL@] A failure thread -- may be exported.
2582 % \item I've no idea what else
2586 \item[\emph{GranSim Info}]
2587 Optional information for gransim execution.
2589 % \item Optional information for GranSim execution:
2595 % \item basic blocks
2602 % \item global sparks
2603 % \item local sparks
2606 % \item clock (gransim light only)
2610 % Here are the various queues for GrAnSim-type events.
2619 \item[\emph{Stack Info}] Various fields contain information on the
2620 stack: its current size, its maximum size (to avoid infinite loops
2621 overflowing the memory), the current stack pointer (\emph{Sp}), the
2622 current stack update frame pointer (\emph{Su}), and the stack limit
2623 (\emph{SpLim}). The latter three fields are loaded into the relevant
2624 registers when the thread is run.
2626 \item[\emph{Stack}] This is the actual stack for the thread,
2627 \emph{Stack size} words long. It grows downwards from higher
2628 addresses to lower addresses. When the stack overflows, it will
2629 generally be relocated into larger premises unless \emph{Max stack
2634 The garbage collector needs to be able to find all the
2635 pointers in a stack. How does it do this?
2639 \item Within the stack there are return addresses, pushed
2640 by @case@ expressions. Below a return address (i.e. at higher
2641 memory addresses, since the stack grows downwards) is a chunk
2642 of stack that the return address ``knows about'', namely the
2643 activation record of the currently running function.
2645 \item Below each such activation record is a \emph{pending-argument
2646 section}, a chunk of
2647 zero or more words that are the arguments to which the result
2648 of the function should be applied. The return address does not
2650 ``know'' how many pending arguments there are, or their types.
2651 (For example, the function might return a result of type $\alpha$.)
2653 \item Below each pending-argument section is another return address,
2654 and so on. Actually, there might be an update frame instead, but we
2655 can consider update frames as a special case of a return address with
2656 a well-defined activation record.
2660 The game plan is this. The garbage collector walks the stack from the
2661 top, traversing pending-argument sections and activation records
2662 alternately. Next we discuss how it finds the pointers in each of
2663 these two stack regions.
2665 \Subsubsection{Activation records}{activation-records}
2667 An \emph{activation record} is a contiguous chunk of stack,
2668 with a return address as its first word, followed by as many
2669 data words as the return address ``knows about''. The return
2670 address is actually a fully-fledged info pointer. It points
2671 to an info table, replete with:
2674 \item entry code (i.e. the code to return to).
2676 \item closure type is either @RET_SMALL/RET_VEC_SMALL@ or
2677 @RET_BIG/RET_VEC_BIG@, depending on whether the activation record has
2678 more than 32 data words (\note{64 for 8-byte-word architectures}) and
2679 on whether to use a direct or a vectored return.
2681 \item the layout info for @RET_SMALL@ is a bitmap telling the layout
2682 of the activation record, one bit per word. The least-significant bit
2683 describes the first data word of the record (adjacent to the fixed
2684 header) and so on. A ``@1@'' indicates a non-pointer, a ``@0@''
2685 indicates a pointer. We don't need to indicate exactly how many words
2686 there are, because when we get to all zeros we can treat the rest of
2687 the activation record as part of the next pending-argument region.
2689 For @RET_BIG@ the layout field points to a block of bitmap words,
2690 starting with a word that tells how many words are in the block.
2692 \item the info table contains a Static Reference Table pointer for the
2693 return address (\secref{srt}).
2696 The activation record is a fully fledged closure too. As well as an
2697 info pointer, it has all the other attributes of a fixed header
2698 (\secref{fixed-header}) including a saved cost centre which
2699 is reloaded when the return address is entered.
2701 In other words, all the attributes of closures are needed for
2702 activation records, so it's very convenient to make them look alike.
2705 \Subsubsection{Pending arguments}{pending-args}
2707 So that the garbage collector can correctly identify pointers in
2708 pending-argument sections we explicitly tag all non-pointers. Every
2709 non-pointer in a pending-argument section is preceded (at the next
2710 lower memory word) by a one-word byte count that says how many bytes
2711 to skip over (excluding the tag word).
2713 The garbage collector traverses a pending argument section from the
2714 top (i.e. lowest memory address). It looks at each word in turn:
2717 \item If it is less than or equal to a small constant @MAX_STACK_TAG@
2718 then it treats it as a tag heralding zero or more words of
2719 non-pointers, so it just skips over them.
2721 \item If it points to the code segment, it must be a return
2722 address, so we have come to the end of the pending-argument section.
2724 \item Otherwise it must be a bona fide heap pointer.
2728 \Subsection{The Stable Pointer Table}{STABLEPTR_TABLE}
2730 A stable pointer is a name for a Haskell object which can be passed to
2731 the external world. It is ``stable'' in the sense that the name does
2732 not change when the Haskell garbage collector runs---in contrast to
2733 the address of the object which may well change.
2735 A stable pointer is represented by an index into the
2736 @StablePointerTable@. The Haskell garbage collector treats the
2737 @StablePointerTable@ as a source of roots for GC.
2739 In order to provide efficient access to stable pointers and to be able
2740 to cope with any number of stable pointers (eg $0 \ldots 100000$), the
2741 table of stable pointers is an array stored on the heap and can grow
2742 when it overflows. (Since we cannot compact the table by moving
2743 stable pointers about, it seems unlikely that a half-empty table can
2744 be reduced in size---this could be fixed if necessary by using a
2745 hash table of some sort.)
2747 In general a stable pointer table closure looks like this:
2750 \begin{tabular}{|l|l|l|l|l|l|l|l|l|l|l|}
2752 \emph{Fixed header} & \emph{No of pointers} & \emph{Free} & $SP_0$ & \ldots & $SP_{n-1}$
2760 \item[@NPtrs@:] number of (stable) pointers.
2762 \item[@Free@:] the byte offset (from the first byte of the object) of the first free stable pointer.
2764 \item[$SP_i$:] A stable pointer slot. If this entry is in use, it is
2765 an ``unstable'' pointer to a closure. If this entry is not in use, it
2766 is a byte offset of the next free stable pointer slot.
2770 When a stable pointer table is evacuated
2772 \item the free list entries are all set to @NULL@ so that the evacuation
2773 code knows they're not pointers;
2775 \item The stable pointer slots are scanned linearly: non-@NULL@ slots
2776 are evacuated and @NULL@-values are chained together to form a new free list.
2779 There's no need to link the stable pointer table onto the mutable
2780 list because we always treat it as a root.
2782 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2783 \Subsection{Garbage Collecting CAFs}{CAF}
2784 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2786 % begin{direct quote from current paper}
2787 A CAF (constant applicative form) is a top-level expression with no
2788 arguments. The expression may need a large, even unbounded, amount of
2789 storage when it is fully evaluated.
2791 CAFs are represented by closures in static memory that are updated
2792 with indirections to objects in the heap space once the expression is
2793 evaluated. Previous version of GHC maintained a list of all evaluated
2794 CAFs and traversed them during GC, the result being that the storage
2795 allocated by a CAF would reside in the heap until the program ended.
2796 % end{direct quote from current paper}
2798 % begin{elaboration on why CAFs are very very bad}
2799 Treating CAFs this way has two problems:
2802 It can cause a very large space leak. For example, this program
2803 should run in constant space but, instead, will run out of memory.
2809 > nats = [0..maxInt]
2813 Expressions with no arguments have very different space behaviour
2814 depending on whether or not they occur at the top level. For example,
2815 if we make \verb+nats+ a local definition, the space leak goes away
2816 and the resulting program runs in constant space, as expected.
2822 > nats = [0..maxInt]
2825 This huge change in the operational behaviour of the program
2826 is a problem for optimising compilers and for programmers.
2827 For example, GHC will normally flatten a set of let bindings using
2828 this transformation:
2830 let x1 = let x2 = e2 in e1 ==> let x2 = e2 in let x1 = e1
2832 but it does not do so if this would raise \verb+x2+ to the top level
2833 since that may create a CAF. Many Haskell programmers avoid creating
2834 large CAFs by adding a dummy argument to a CAF or by moving a CAF away
2838 % end{elaboration on why CAFs are very very bad}
2840 Solving the CAF problem requires different treatment in interactive
2841 systems such as Hugs than in batch-mode systems such as GHC
2844 In a batch-mode the program the runtime system is terminated
2845 after every execution of the runtime system. In such systems,
2846 the garbage collector can completely ``destroy'' a CAF when it
2847 is no longer live --- in much the same way as it ``destroys''
2848 normal closures when they are no longer live.
2851 In an interactive system, many expressions are evaluated without
2852 restarting the runtime system between each evaluation. In such
2853 systems, the garbage collector cannot completely ``destroy'' a CAF
2854 when it is no longer live because, whilst it might not be required in
2855 the evaluation of the current expression, it might be required in the
2858 There are two possible behaviours we migth want:
2861 When a CAF is no longer required for the current evaluation, the CAF
2862 should be reverted to its original form. This behaviour ensures that
2863 the operational behaviour of the interactive system is a reasonable
2864 predictor of the operational behaviour of the batch-mode system. This
2865 allows us to use Hugs for performance debugging (in particular, trying
2866 to understand and reduce the heap usage of a program) --- an area of
2867 increasing importance as Haskell is used more and more to solve ``real
2868 problems'' in ``real problem domains''.
2871 Even if a CAF is no longer required for the current evaluation, we might
2872 choose to hang onto it by collecting it in the normal way. This keeps
2873 the space leak but might be useful in a teaching environment when
2874 trying to teach the difference between call by name evaluation (which
2875 doesn't share work) and lazy evaluation (which does share work).
2879 It turns out that it is easy to support both styles of use, so the
2880 runtime system provides a switch which lets us turn this on and off
2881 during execution. \ToDo{What is this switch called?} It would also
2882 be easy to provide a function \verb+RevertCAF+ to let the interpreter
2883 revert any CAF it wanted between (but not during) executions, if we so
2884 desired. Running \verb+RevertCAF+ during execution would lose some sharing
2885 but is otherwise harmless.
2889 % % begin{even more pointless observation?}
2890 % The simplest fix would be to remove the special treatment of
2891 % top level variables. This works but is very inefficient.
2893 % (Note: delete this paragraph from final version.)
2894 % % end{even more pointless observation?}
2896 % begin{pointless observation?}
2897 An easy but inefficient fix to the CAF problem would be to make a
2898 complete copy of the heap before every evaluation and discard the copy
2899 after evaluation. This works but is inefficient.
2900 % end{pointless observation?}
2902 An efficient way to achieve a similar effect is to revert all
2903 updatable thunks to their original form as they become unnecessary for
2904 the current evaluation. To do this, we modify the compiler to ensure
2905 that the only updatable thunks generated by the compiler are CAFs and
2906 we modify the garbage collector to revert entered CAFs to unentered
2907 CAFs as their value becomes unnecessary.
2910 \subsubsection{New Heap Objects}
2912 We add three new kinds of heap object: unentered CAF closures, entered
2913 CAF objects and CAF blackholes. We first describe how they are
2914 evaluated and then how they are garbage collected.
2917 Unentered CAF closures contain a pointer to closure representing the
2918 body of the CAF. The ``body closure'' is not updatable.
2920 Unentered CAF closures contain two unused fields to make them the same
2921 size as entered CAF closures --- which allows us to perform an inplace
2922 update. \ToDo{Do we have to add another kind of inplace update operation
2923 to the storage manager interface or do we consider this to be internal
2926 \begin{tabular}{|l|l|l|l|}\hline
2927 \verb+CAF_unentered+ & \emph{body closure} & \emph{unused} & \emph{unused} \\ \hline
2930 When an unentered CAF is entered, we do the following:
2933 allocate a CAF black hole;
2936 push an update frame (to update the CAF black hole) onto the stack;
2939 overwrite the CAF with an entered CAF object (see below) with the same
2940 body and whose value field points to the black hole;
2943 add the CAF to a list of all entered CAFs (called ``the CAF list'');
2947 the closure representing the value of the CAF is entered.
2951 When evaluation of the CAF body returns a value, the update frame
2952 causes the CAF black hole to be updated with the value in the normal
2955 \ToDo{Add a picture}
2958 Entered CAF closures contain two pointers: a pointer to the CAF body
2959 (the same as for unentered CAF closures); a pointer to the CAF value
2960 (this is initialised with a CAF blackhole, as previously described);
2961 and a link to the next CAF in the CAF list
2963 \ToDo{How is the end of the list marked? Null pointer or sentinel value?}.
2966 \begin{tabular}{|l|l|l|l|}\hline
2967 \verb+CAF_entered+ & \emph{body closure} & \emph{value} & \emph{link} \\ \hline
2970 When an entered CAF is entered, it enters its value closure.
2973 CAF blackholes are identical to normal blackholes except that they
2974 have a different infotable. The only reason for having CAF blackholes
2975 is to allow an optimisation of lazy blackholing where we stop scanning
2976 the stack when we see the first {\em normal blackhole} but not
2977 when we see a {\em CAF blackhole.}
2978 \ToDo{The optimisation we want to allow should be described elsewhere
2979 so that all we have to do here is describe the difference.}
2981 Instead of allocating a blackhole to update with the value of the CAF,
2982 it might seem simpler to update the CAF directly. This would require
2983 a new kind of update frame which would update the value field of the
2984 CAF with a pointer to the value and wouldn't catch blackholes caused
2985 by CAFs that depend on themselves so we chose not to do so.
2989 \subsubsection{Garbage Collection}
2991 To avoid the space leak, each run of the garbage collector must revert
2992 the entered CAFs which are not required to complete the current
2993 evaluation (that is all the closures reachable from the set of
2994 runnable threads and the stable pointer table).
2996 It does this by performing garbage collection in three phases:
2999 During the first phase, we ``mark'' all closures reachable from the
3002 How we ``mark'' closures depends on the garbage collector. For
3003 example, in a 2-space collector, closures are ``marked'' by copying
3004 them into ``to-space'', overwriting them with a forwarding node and
3005 ``marking'' all the closures reachable from the copy. The only
3006 requirements are that we can test whether a closure is marked and if a
3007 closure is marked then so are all closures reachable from it.
3009 \ToDo{At present we say that the scheduler state includes any state
3010 that Hugs may have. This is not true anymore.}
3012 Performing this phase first provides us with a cheap test for
3013 execution closures: at this stage in execution, the execution closures
3014 are precisely the marked closures.
3017 During the second phase, we revert all unmarked CAFs on the CAF list
3018 and remove them from the CAF list.
3020 Since the CAF list is exactly the set of all entered CAFs, this reverts
3021 all entered CAFs which are not execution closures.
3024 During the third phase, we mark all top level objects (including CAFs)
3025 by calling \verb+MarkHugsRoots+ which will call \verb+MarkRoot+ for
3026 each top level object known to Hugs.
3030 To implement the second style of interactive behaviour (where we
3031 deliberately keep the CAF-related space leak), we simply omit the
3032 second phase. Omitting the second phase causes the third phase to
3033 mark any unmarked CAF value closures.
3035 So far, we have been describing a pure Hugs system which contains no
3036 machine generated code. The main difference in a hybrid system is
3037 that GHC-generated code is statically allocated in memory instead of
3038 being dynamically allocated on the heap. We split both
3039 \verb+CAF_unentered+ and \verb+CAF_entered+ into two versions: a
3040 static and a dynamic version. The static and dynamic versions of each
3041 CAF differ only in whether they are moved during garbage collection.
3042 When reverting CAFs, we revert dynamic entered CAFs to dynamic
3043 unentered CAFs and static entered CAFs to static unentered CAFs.
3048 \Section{The Bytecode Evaluator}{bytecode-evaluator}
3050 This section describes how the Hugs interpreter interprets code in the
3051 same environment as compiled code executes. Both evaluation models
3052 use a common garbage collector, so they must agree on the form of
3053 objects in the heap.
3055 Hugs interprets code by converting it to byte-code and applying a
3056 byte-code interpreter to it. Wherever possible, we try to ensure that
3057 the byte-code is all that is required to interpret a section of code.
3058 This means not dynamically generating info tables, and hence we can
3059 only have a small number of possible heap objects each with a statically
3060 compiled info table. Similarly for stack objects: in fact we only
3061 have one Hugs stack object, in which all information is tagged for the
3064 There is, however, one exception to this rule. Hugs must generate
3065 info tables for any constructors it is asked to compile, since the
3066 alternative is to force a context-switch each time compiled code
3067 enters a Hugs-built constructor, which would be prohibitively
3070 We achieve this simplicity by forgoing some of the optimisations used
3075 Whereas compiled code has five different ways of entering a closure
3076 (\secref{entering-closures}), interpreted code has only one.
3077 The entry point for interpreted code behaves like slow entry points for
3082 We use just one info table for \emph{all\/} direct returns.
3083 This introduces two problems:
3085 \item How does the interpreter know what code to execute?
3087 Instead of pushing just a return address, we push a return BCO and a
3088 trivial return address which just enters the return BCO.
3090 (In a purely interpreted system, we could avoid pushing the trivial
3093 \item How can the garbage collector follow pointers within the
3096 We could push a third word ---a bitmask describing the location of any
3097 pointers within the record--- but, since we're already tagging unboxed
3098 function arguments on the stack, we use the same mechanism for unboxed
3099 values within the activation record.
3101 \ToDo{Do we have to stub out dead variables in the activation frame?}
3107 We trivially support vectored returns by pushing a return vector whose
3108 entries are all the same.
3112 We avoid the need to build SRTs by putting bytecode objects on the
3113 heap and restricting BCOs to a single basic block.
3117 \Subsection{Hugs Info Tables}{hugs-info-tables}
3119 Hugs requires the following info tables and closures:
3123 Contains both a vectored return table and a direct entry point. All
3124 entry points are the same: they rearrange the stack to match the Hugs
3125 return convention (\secref{hugs-return-convention}) and return to the
3126 scheduler. When the scheduler restarts the thread, it will find a BCO
3127 on top of the stack and will enter the Hugs interpreter.
3131 This is just the standard info table for an update frame.
3133 \item [Constructors].
3135 The entry code for a constructor jumps to a generic entry point in the
3136 runtime system which decides whether to do a vectored or unvectored
3137 return depending on the shape of the constructor/type. This implies that
3138 info tables must have enough info to make that decision.
3140 \item [@AP@ and @PAP@].
3142 \item [Indirections].
3146 Hugs doesn't generate them itself but it ought to recognise them
3148 \item [Complex primops].
3150 Some of the primops are too complex for GHC to generate inline.
3151 Instead, these primops are hand-written and called as normal functions.
3152 Hugs only needs to know their names and types but doesn't care whether
3153 they are generated by GHC or by hand. Two things to watch:
3157 Hugs must be able to enter these primops even if it is working on a
3158 standalone system that does not support genuine GHC generated code.
3160 \item The complex primops often involve unboxed tuple types (which
3161 Hugs does not support at the source level) so we cannot specify their
3162 types in a Haskell source file.
3168 \Subsection{Hugs Heap Objects}{hugs-heap-objects}
3170 \subsubsection{Byte-code objects}
3172 Compiled byte code lives on the global heap, in objects called
3173 Byte-Code Objects (or BCOs). The layout of BCOs is described in
3174 detail in \secref{BCO}, in this section we will describe
3177 Since byte-code lives on the heap, it can be garbage collected just
3178 like any other heap-resident data. Hugs arranges that any BCO's
3179 referred to by the Hugs symbol tables are treated as live objects by
3180 the garbage collector. When a module is unloaded, the pointers to its
3181 BCOs are removed from the symbol table, and the code will be garbage
3182 collected some time later.
3184 A BCO represents a basic block of code --- the (only) entry points is
3185 at the beginning of a BCO, and it is impossible to jump into the
3186 middle of one. A BCO represents not only the code for a function, but
3187 also its closure; a BCO can be entered just like any other closure.
3188 Hugs performs lambda-lifting during compilation to byte-code, and each
3189 top-level combinator becomes a BCO in the heap.
3192 \subsubsection{Thunks and partial applications}
3194 A thunk consists of a code pointer, and values for the free variables
3195 of that code. Since Hugs byte-code is lambda-lifted, free variables
3196 become arguments and are expected to be on the stack by the called
3199 Hugs represents updateable thunks with @AP_UPD@ objects applying a closure
3200 to a list of arguments. (As for @PAP@s, unboxed arguments should be
3201 preceded by a tag.) When it is entered, it pushes an update frame
3202 followed by its payload on the stack, and enters the first word (which
3203 will be a pointer to a BCO). The layout of @AP_UPD@ objects is described
3204 in more detail in \secref{AP_UPD}.
3206 Partial applications are represented by @PAP@ objects, which are
3209 \ToDo{Hugs Constructors}.
3211 \Subsection{Calling conventions}{hugs-calling-conventions}
3213 The calling convention for any byte-code function is straightforward:
3215 \item Push any arguments on the stack.
3216 \item Push a pointer to the BCO.
3217 \item Begin interpreting the byte code.
3220 In a system containing both GHC and Hugs, the bytecode interpreter
3221 only has to be able to enter BCOs: everything else can be handled by
3222 returning to the compiled world (as described in
3223 \secref{hugs-to-ghc-switch}) and entering the closure
3226 This would work but it would obviously be very inefficient if we
3227 entered a @AP@ by switching worlds, entering the @AP@, pushing the
3228 arguments and function onto the stack, and entering the function
3229 which, likely as not, will be a byte-code object which we will enter
3230 by \emph{returning} to the byte-code interpreter. To avoid such
3231 gratuitious world switching, we choose to recognise certain closure
3232 types as being ``standard'' --- and duplicate the entry code for the
3233 ``standard closures'' in the bytecode interpreter.
3235 A closure is said to be ``standard'' if its entry code is entirely
3236 determined by its info table. \emph{Standard Closures} have the
3237 desirable property that the byte-code interpreter can enter the
3238 closure by simply ``interpreting'' the info table instead of switching
3239 to the compiled world. The standard closures include:
3242 \item[Constructor] To enter a constructor, we simply return (see
3243 \secref{hugs-return-convention}).
3246 To enter an indirection, we simply enter the object it points to
3247 after possibly adjusting the current cost centre.
3251 To enter an @AP@, we push an update frame, push the
3252 arguments, push the function and enter the function.
3253 (Not forgetting a stack check at the start.)
3257 To enter a @PAP@, we push the arguments, push the function and enter
3258 the function. (Not forgetting a stack check at the start.)
3262 To enter a selector (\secref{THUNK_SELECTOR}), we test whether the
3263 selectee is a value. If so, we simply select the appropriate
3264 component; if not, it's simplest to treat it as a GHC-built closure
3265 --- though we could interpret it if we wanted.
3269 The most obvious omissions from the above list are @BCO@s (which we
3270 dealt with above) and GHC-built closures (which are covered in
3271 \secref{hugs-to-ghc-switch}).
3274 \Subsection{Return convention}{hugs-return-convention}
3276 When Hugs pushes a return address, it pushes both a pointer to the BCO
3277 to return to, and a pointer to a static code fragment @HUGS_RET@ (this
3278 is described in \secref{ghc-to-hugs-switch}). The
3279 stack layout is shown in \figref{hugs-return-stack}.
3291 %\input{hugs_ret.pstex_t}
3293 \caption{Stack layout for a Hugs return address}
3294 \label{fig:hugs-return-stack}
3305 %\input{hugs_ret2.pstex_t}
3307 \caption{Stack layout on enterings a Hugs return address}
3308 \label{fig:hugs-return2}
3321 %\input{hugs_ret2.pstex_t}
3323 \caption{Stack layout on entering a Hugs return address with an unboxed value}
3324 \label{fig:hugs-return-int}
3337 %\input{hugs_ret3.pstex_t}
3339 \caption{Stack layout on enterings a GHC return address}
3340 \label{fig:hugs-return3}
3354 | restart |--> id_Int#_closure
3357 %\input{hugs_ret2.pstex_t}
3359 \caption{Stack layout on enterings a GHC return address with an unboxed value}
3360 \label{fig:hugs-return-int}
3363 When a Hugs byte-code sequence enters a closure, it examines the
3364 return address on top of the stack.
3368 \item If the return address is @HUGS_RET@, pop the @HUGS_RET@ and the
3369 bco for the continuation off the stack, push a pointer to the constructor onto
3370 the stack and enter the BCO with the current object pointer set to the BCO
3371 (\figref{hugs-return2}).
3373 \item If the top of the stack is not @HUGS_RET@, we need to do a world
3374 switch as described in \secref{hugs-to-ghc-switch}.
3378 \ToDo{This duplicates what we say about switching worlds
3379 (\secref{switching-worlds}) - kill one or t'other.}
3382 \ToDo{This was in the evaluation model part but it really belongs in
3383 this part which is about the internal details of each of the major
3386 \Subsection{Addressing Modes}{hugs-addressing-modes}
3388 To avoid potential alignment problems and simplify garbage collection,
3389 all literal constants are stored in two tables (one boxed, the other
3390 unboxed) within each BCO and are referred to by offsets into the tables.
3391 Slots in the constant tables are word aligned.
3393 \ToDo{How big can the offsets be? Is the offset specified in the
3394 address field or in the instruction?}
3396 Literals can have the following types: char, int, nat, float, double,
3397 and pointer to boxed object. There is no real difference between
3398 char, int, nat and float since they all occupy 32 bits --- but it
3399 costs almost nothing to distinguish them and may improve portability
3400 and simplify debugging.
3402 \Subsection{Compilation}{hugs-compilation}
3405 \def\is{\mbox{\it is}}
3406 \def\ts{\mbox{\it ts}}
3407 \def\as{\mbox{\it as}}
3408 \def\bs{\mbox{\it bs}}
3409 \def\cs{\mbox{\it cs}}
3410 \def\rs{\mbox{\it rs}}
3411 \def\us{\mbox{\it us}}
3412 \def\vs{\mbox{\it vs}}
3413 \def\ws{\mbox{\it ws}}
3414 \def\xs{\mbox{\it xs}}
3416 \def\e{\mbox{\it e}}
3417 \def\alts{\mbox{\it alts}}
3418 \def\fail{\mbox{\it fail}}
3419 \def\panic{\mbox{\it panic}}
3420 \def\ua{\mbox{\it ua}}
3421 \def\obj{\mbox{\it obj}}
3422 \def\bco{\mbox{\it bco}}
3423 \def\tag{\mbox{\it tag}}
3424 \def\entry{\mbox{\it entry}}
3425 \def\su{\mbox{\it su}}
3427 \def\Ind#1{{\mbox{\it Ind}\ {#1}}}
3428 \def\update#1{{\mbox{\it update}\ {#1}}}
3430 \def\next{$\Longrightarrow$}
3431 \def\append{\mathrel{+\mkern-6mu+}}
3432 \def\reverse{\mbox{\it reverse}}
3433 \def\size#1{{\vert {#1} \vert}}
3434 \def\arity#1{{\mbox{\it arity}{#1}}}
3436 \def\AP{\mbox{\it AP}}
3437 \def\PAP{\mbox{\it PAP}}
3438 \def\GHCRET{\mbox{\it GHCRET}}
3439 \def\GHCOBJ{\mbox{\it GHCOBJ}}
3441 To make sense of the instructions, we need a sense of how they will be
3442 used. Here is a small compiler for the STG language.
3445 > cg (f{a1, ... am}) = do
3446 > pushAtom am; ... pushAtom a1
3450 > cg (let {x1=rhs1; ... xm=rhsm} in e) = do
3451 > ALLOC x1 |rhs1|, ... ALLOC xm |rhsm|
3452 > build x1 rhs1, ... build xm rhsm
3454 > cg (case e of alts) = do
3455 > PUSHALTS (cgAlts alts)
3458 > cgAlts { alt1; ... altm } = cgAlt alt1 $ ... $ cgAlt altm pmFail
3460 > cgAlt (x@C{xs} -> e) fail = do
3462 > HEAPCHECK (heapUse e)
3466 > build x (C{a1, ... am}) = do
3467 > pushUntaggedAtom am; ... pushUntaggedAtom a1
3469 > -- A useful optimisation
3470 > build x ({v1, ... vm} \ {}. f{a1, ... am}) = do
3471 > pushVar am; ... pushVar a1
3474 > build x ({v1, ... vm} \ {}. e) = do
3475 > pushVar vm; ... pushVar v1
3476 > PUSHBCO (cgRhs ({v1, ... vm} \ {}. e))
3478 > build x ({v1, ... vm} \ {x1, ... xm}. e) = do
3479 > pushVar vm; ... pushVar v1
3480 > PUSHBCO (cgRhs ({v1, ... vm} \ {x1, ... xm}. e))
3483 > cgRhs (vs \ xs. e) = do
3484 > ARGCHECK (xs ++ vs) -- can be omitted if xs == {}
3485 > STACKCHECK min(stackUse e,heapOverflowSlop)
3486 > HEAPCHECK (heapUse e)
3489 > pushAtom x = pushVar x
3490 > pushAtom i# = PUSHINT i#
3492 > pushVar x = if isGlobalVar x then PUSHGLOBAL x else PUSHLOCAL x
3494 > pushUntaggedAtom x = pushVar x
3495 > pushUntaggedAtom i# = PUSHUNTAGGEDINT i#
3497 > pushVar x = if isGlobalVar x then PUSHGLOBAL x else PUSHLOCAL x
3500 \ToDo{Is there an easy way to add semi-tagging? Would it be that different?}
3502 \ToDo{Optimise thunks of the form @f{x1,...xm}@ so that we build an AP directly}
3504 \Subsection{Instructions}{hugs-instructions}
3506 We specify the semantics of instructions using transition rules of
3509 \begin{tabular}{|llrrrrr|}
3511 & $\is$ & $s$ & $\su$ & $h$ & $hp$ & $\sigma$ \\
3512 \next & $\is'$ & $s'$ & $\su'$ & $h'$ & $hp'$ & $\sigma$ \\
3516 where $\is$ is an instruction stream, $s$ is the stack, $\su$ is the
3517 update frame pointer and $h$ is the heap.
3520 \Subsection{Stack manipulation}{hugs-stack-manipulation}
3524 \item[ Push a global variable ].
3526 \begin{tabular}{|llrrrrr|}
3528 & PUSHGLOBAL $o$ : $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3529 \next & $\is$ & $\sigma!o:s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3533 \item[ Push a local variable ].
3535 \begin{tabular}{|llrrrrr|}
3537 & PUSHLOCAL $o$ : $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3538 \next & $\is$ & $s!o : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3542 \item[ Push an unboxed int ].
3544 \begin{tabular}{|llrrrrr|}
3546 & PUSHINT $o$ : $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3547 \next & $\is$ & $I\# : \sigma!o : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3551 The $I\#$ is a tag included for the benefit of the garbage collector.
3552 Similar rules exist for floats, doubles, chars, etc.
3554 \item[ Push an unboxed int ].
3556 \begin{tabular}{|llrrrrr|}
3558 & PUSHUNTAGGEDINT $o$ : $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3559 \next & $\is$ & $\sigma!o : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3563 Similar rules exist for floats, doubles, chars, etc.
3565 \item[ Delete environment from stack --- ready for tail call ].
3567 \begin{tabular}{|llrrrrr|}
3569 & SLIDE $m$ $n$ : $\is$ & $\as \append \bs \append \cs$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3570 \next & $\is$ & $\as \append \cs$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3574 where $\size{\as} = m$ and $\size{\bs} = n$.
3577 \item[ Push a return address ].
3579 \begin{tabular}{|llrrrrr|}
3581 & PUSHALTS $o$:$\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3582 \next & $\is$ & $@HUGS_RET@:\sigma!o:s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3586 \item[ Push a BCO ].
3588 \begin{tabular}{|llrrrrr|}
3590 & PUSHBCO $o$ : $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3591 \next & $\is$ & $\sigma!o : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3597 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3598 \Subsection{Heap manipulation}{hugs-heap-manipulation}
3599 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3603 \item[ Allocate a heap object ].
3605 \begin{tabular}{|llrrrrr|}
3607 & ALLOC $m$ : $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3608 \next & $\is$ & $hp:s$ & $su$ & $h$ & $hp+m$ & $\sigma$ \\
3612 \item[ Build a constructor ].
3614 \begin{tabular}{|llrrrrr|}
3616 & PACK $o$ $o'$ : $\is$ & $\ws \append s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3617 \next & $\is$ & $s$ & $su$ & $h[s!o \mapsto Pack C\{\ws\}]$ & $hp$ & $\sigma$ \\
3621 where $C = \sigma!o'$ and $\size{\ws} = \arity{C}$.
3623 \item[ Build an AP or PAP ].
3625 \begin{tabular}{|llrrrrr|}
3627 & MKAP $o$ $m$:$\is$ & $f : \ws \append s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3628 \next & $\is$ & $s$ & $su$ & $h[s!o \mapsto \AP(f,\ws)]$ & $hp$ & $\sigma$ \\
3632 where $\size{\ws} = m$.
3634 \begin{tabular}{|llrrrrr|}
3636 & MKPAP $o$ $m$:$\is$ & $f : \ws \append s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3637 \next & $\is$ & $s$ & $su$ & $h[s!o \mapsto \PAP(f,\ws)]$ & $hp$ & $\sigma$ \\
3641 where $\size{\ws} = m$.
3643 \item[ Unpacking a constructor ].
3645 \begin{tabular}{|llrrrrr|}
3647 & UNPACK : $is$ & $a : s$ & $su$ & $h[a \mapsto C\ \ws]$ & $hp$ & $\sigma$ \\
3648 \next & $is'$ & $(\reverse\ \ws) \append a : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3652 The $\reverse\ \ws$ looks expensive but, since the stack grows down
3653 and the heap grows up, that's actually the cheap way of copying from
3654 heap to stack. Looking at the compilation rules, you'll see that we
3655 always push the args in reverse order.
3660 \Subsection{Entering a closure}{hugs-entering}
3664 \item[ Enter a BCO ].
3666 \begin{tabular}{|llrrrrr|}
3668 & [ENTER] & $a : s$ & $su$ & $h[a \mapsto BCO\{\is\} ]$ & $hp$ & $\sigma$ \\
3669 \next & $\is$ & $a : s$ & $su$ & $h$ & $hp$ & $a$ \\
3673 \item[ Enter a PAP closure ].
3675 \begin{tabular}{|llrrrrr|}
3677 & [ENTER] & $a : s$ & $su$ & $h[a \mapsto \PAP(f,\ws)]$ & $hp$ & $\sigma$ \\
3678 \next & [ENTER] & $f : \ws \append s$ & $su$ & $h$ & $hp$ & $???$ \\
3682 \item[ Entering an AP closure ].
3684 \begin{tabular}{|llrrrrr|}
3686 & [ENTER] & $a : s$ & $su$ & $h[a \mapsto \AP(f,ws)]$ & $hp$ & $\sigma$ \\
3687 \next & [ENTER] & $f : \ws \append @UPD_RET@:\su:a:s$ & $su'$ & $h$ & $hp$ & $???$ \\
3693 \item Instead of blindly pushing an update frame for $a$, we can first test whether there's already
3694 an update frame there. If so, overwrite the existing updatee with an indirection to $a$ and
3695 overwrite the updatee field with $a$. (Overwriting $a$ with an indirection to the updatee also
3696 works.) This results in update chains of maximum length 2.
3700 \item[ Returning a constructor ].
3702 \begin{tabular}{|llrrrrr|}
3704 & [ENTER] & $a : @HUGS_RET@ : \alts : s$ & $su$ & $h[a \mapsto C\{\ws\}]$ & $hp$ & $\sigma$ \\
3705 \next & $\alts.\entry$ & $a:s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3710 \item[ Entering an indirection node ].
3712 \begin{tabular}{|llrrrrr|}
3714 & [ENTER] & $a : s$ & $su$ & $h[a \mapsto \Ind{a'}]$ & $hp$ & $\sigma$ \\
3715 \next & [ENTER] & $a' : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3719 \item[Entering GHC closure].
3721 \begin{tabular}{|llrrrrr|}
3723 & [ENTER] & $a : s$ & $su$ & $h[a \mapsto \GHCOBJ]$ & $hp$ & $\sigma$ \\
3724 \next & [ENTERGHC] & $a : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3728 \item[Returning a constructor to GHC].
3730 \begin{tabular}{|llrrrrr|}
3732 & [ENTER] & $a : \GHCRET : s$ & $su$ & $h[a \mapsto C \ws]$ & $hp$ & $\sigma$ \\
3733 \next & [ENTERGHC] & $a : \GHCRET : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3740 \Subsection{Updates}{hugs-updates}
3744 \item[ Updating with a constructor].
3746 \begin{tabular}{|llrrrrr|}
3748 & [ENTER] & $a : @UPD_RET@ : ua : s$ & $su$ & $h[a \mapsto C\{\ws\}]$ & $hp$ & $\sigma$ \\
3749 \next & [ENTER] & $a \append s$ & $su$ & $h[au \mapsto \Ind{a}$ & $hp$ & $\sigma$ \\
3753 \item[ Argument checks].
3755 \begin{tabular}{|llrrrrr|}
3757 & ARGCHECK $m$:$\is$ & $a : \as \append s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3758 \next & $\is$ & $a : \as \append s$ & $su$ & $h'$ & $hp$ & $\sigma$ \\
3762 where $m \ge (su - sp)$
3764 \begin{tabular}{|llrrrrr|}
3766 & ARGCHECK $m$:$\is$ & $a : \as \append @UPD_RET@:su:ua:s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3767 \next & $\is$ & $a : \as \append s$ & $su$ & $h'$ & $hp$ & $\sigma$ \\
3771 where $m < (su - sp)$ and
3772 $h' = h[ua \mapsto \Ind{a'}, a' \mapsto \PAP(a,\reverse\ \as) ]$
3774 Again, we reverse the list of values as we transfer them from the
3775 stack to the heap --- reflecting the fact that the stack and heap grow
3776 in different directions.
3780 \Subsection{Branches}{hugs-branches}
3784 \item[ Testing a constructor ].
3786 \begin{tabular}{|llrrrrr|}
3788 & TEST $tag$ $is'$ : $is$ & $a : s$ & $su$ & $h[a \mapsto C\ \ws]$ & $hp$ & $\sigma$ \\
3789 \next & $is$ & $a : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3793 where $C.\tag = tag$
3795 \begin{tabular}{|llrrrrr|}
3797 & TEST $tag$ $is'$ : $is$ & $a : s$ & $su$ & $h[a \mapsto C\ \ws]$ & $hp$ & $\sigma$ \\
3798 \next & $is'$ & $a : s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3802 where $C.\tag \neq tag$
3806 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3807 \Subsection{Heap and stack checks}{hugs-heap-stack-checks}
3808 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3810 \begin{tabular}{|llrrrrr|}
3812 & STACKCHECK $stk$:$\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3813 \next & $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3817 if $s$ has $stk$ free slots.
3819 \begin{tabular}{|llrrrrr|}
3821 & HEAPCHECK $hp$:$\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3822 \next & $\is$ & $s$ & $su$ & $h$ & $hp$ & $\sigma$ \\
3826 if $h$ has $hp$ free slots.
3828 If either check fails, we push the current bco ($\sigma$) onto the
3829 stack and return to the scheduler. When the scheduler has fixed the
3830 problem, it pops the top object off the stack and reenters it.
3835 \item The bytecode CHECK1000 conservatively checks for 1000 words of heap space and 1000 words of stack space.
3836 We use it to reduce code space and instruction decoding time.
3837 \item The bytecode HEAPCHECK1000 conservatively checks for 1000 words of heap space.
3838 It is used in case alternatives.
3842 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3843 \Subsection{Primops}{hugs-primops}
3844 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3846 \ToDo{primops take m words and return n words. The expect boxed arguments on the stack.}
3849 \Section{The Machine Code Evaluator}{asm-evaluator}
3851 This section describes the framework in which compiled code evaluates
3852 expressions. Only at certain points will compiled code need to be
3853 able to talk to the interpreted world; these are discussed in
3854 \secref{switching-worlds}.
3856 \Subsection{Calling conventions}{ghc-calling-conventions}
3858 \Subsubsection{The call/return registers}{ghc-regs}
3860 One of the problems in designing a virtual machine is that we want it
3861 abstract away from tedious machine details but still reveal enough of
3862 the underlying hardware that we can make sensible decisions about code
3863 generation. A major problem area is the use of registers in
3864 call/return conventions. On a machine with lots of registers, it's
3865 cheaper to pass arguments and results in registers than to pass them
3866 on the stack. On a machine with very few registers, it's cheaper to
3867 pass arguments and results on the stack than to use ``virtual
3868 registers'' in memory. We therefore use a hybrid system: the first
3869 $n$ arguments or results are passed in registers; and the remaining
3870 arguments or results are passed on the stack. For register-poor
3871 architectures, it is important that we allow $n=0$.
3873 We'll label the arguments and results \Arg{1} \ldots \Arg{m} --- with
3874 the understanding that \Arg{1} \ldots \Arg{n} are in registers and
3875 \Arg{n+1} \ldots \Arg{m} are on top of the stack.
3877 Note that the mapping of arguments \Arg{1} \ldots \Arg{n} to machine
3878 registers depends on the \emph{kinds} of the arguments. For example,
3879 if the first argument is a Float, we might pass it in a different
3880 register from if it is an Int. In fact, we might find that a given
3881 architecture lets us pass varying numbers of arguments according to
3882 their types. For example, if a CPU has 2 Int registers and 2 Float
3883 registers then we could pass between 2 and 4 arguments in machine
3884 registers --- depending on whether they all have the same kind or they
3885 have different kinds.
3887 \Subsubsection{Entering closures}{entering-closures}
3889 To evaluate a closure we jump to the entry code for the closure
3890 passing a pointer to the closure in \Arg{1} so that the entry code can
3891 access its environment.
3893 \Subsubsection{Function call}{ghc-fun-call}
3895 The function-call mechanism is obviously crucial. There are five different
3899 \item \emph{Known combinator (function with no free variables) and
3902 A fast call can be made: push excess arguments onto stack and jump to
3903 function's \emph{fast entry point} passing arguments in \Arg{1} \ldots
3906 The \emph{fast entry point} is only called with exactly the right
3907 number of arguments (in \Arg{1} \ldots \Arg{m}) so it can instantly
3908 start doing useful work without first testing whether it has enough
3909 registers or having to pop them off the stack first.
3911 \item \emph{Known combinator and insufficient arguments.}
3913 A slow call can be made: push all arguments onto stack and jump to
3914 function's \emph{slow entry point}.
3916 Any unpointed arguments which are pushed on the stack must be tagged.
3917 This means pushing an extra word on the stack below the unpointed
3918 words, containing the number of unpointed words above it.
3920 %Todo: forward ref about tagging?
3923 The \emph{slow entry point} might be called with insufficient arguments
3924 and so it must test whether there are enough arguments on the stack.
3925 This \emph{argument satisfaction check} consists of checking that
3926 @Su-Sp@ is big enough to hold all the arguments (including any tags).
3930 \item If the argument satisfaction check fails, it is because there is
3931 one or more update frames on the stack before the rest of the
3932 arguments that the function needs. In this case, we construct a PAP
3933 (partial application, \secref{PAP}) containing the arguments
3934 which are on the stack. The PAP construction code will return to the
3935 update frame with the address of the PAP in \Arg{1}.
3937 \item If the argument satisfaction check succeeds, we jump to the fast
3938 entry point with the arguments in \Arg{1} \ldots \Arg{arity}.
3940 If the fast entry point expects to receive some of \Arg{i} on the
3941 stack, we can reduce the amount of movement required by making the
3942 stack layout for the fast entry point look like the stack layout for
3943 the slow entry point. Since the slow entry point is entered with the
3944 first argument on the top of the stack and with tags in front of any
3945 unpointed arguments, this means that if \Arg{i} is unpointed, there
3946 should be space below it for a tag and that the highest numbered
3947 argument should be passed on the top of the stack.
3949 We usually arrange that the fast entry point is placed immediately
3950 after the slow entry point --- so we can just ``fall through'' to the
3951 fast entry point without performing a jump.
3956 \item \emph{Known function closure (function with free variables) and
3959 A fast call can be made: push excess arguments onto stack and jump to
3960 function's \emph{fast entry point} passing a pointer to closure in
3961 \Arg{1} and arguments in \Arg{2} \ldots \Arg{m+1}.
3963 Like the fast entry point for a combinator, the fast entry point for a
3964 closure is only called with appropriate values in \Arg{1} \ldots
3965 \Arg{m+1} so we can start work straight away. The pointer to the
3966 closure is used to access the free variables of the closure.
3969 \item \emph{Known function closure and insufficient arguments.}
3971 A slow call can be made: push all arguments onto stack and jump to the
3972 closure's slow entry point passing a pointer to the closure in \Arg{1}.
3974 Again, the slow entry point performs an argument satisfaction check
3975 and either builds a PAP or pops the arguments off the stack into
3976 \Arg{2} \ldots \Arg{m+1} and jumps to the fast entry point.
3979 \item \emph{Unknown function closure, thunk or constructor.}
3981 Sometimes, the function being called is not statically identifiable.
3982 Consider, for example, the @compose@ function:
3984 compose f g x = f (g x)
3986 Since @f@ and @g@ are passed as arguments to @compose@, the latter has
3987 to make a heap call. In a heap call the arguments are pushed onto the
3988 stack, and the closure bound to the function is entered. In the
3989 example, a thunk for @(g x)@ will be allocated, (a pointer to it)
3990 pushed on the stack, and the closure bound to @f@ will be
3991 entered. That is, we will jump to @f@s entry point passing @f@ in
3992 \Arg{1}. If \Arg{1} is passed on the stack, it is pushed on top of
3993 the thunk for @(g x)@.
3995 The \emph{entry code} for an updateable thunk (which must have arity 0)
3996 pushes an update frame on the stack and starts executing the body of
3997 the closure --- using \Arg{1} to access any free variables. This is
3998 described in more detail in \secref{data-updates}.
4000 The \emph{entry code} for a non-updateable closure is just the
4001 closure's slow entry point.
4005 In addition to the above considerations, if there are \emph{too many}
4006 arguments then the extra arguments are simply pushed on the stack with
4009 To summarise, a closure's standard (slow) entry point performs the
4013 \item[Argument satisfaction check.] (function closure only)
4014 \item[Stack overflow check.]
4015 \item[Heap overflow check.]
4016 \item[Copy free variables out of closure.] %Todo: why?
4017 \item[Eager black holing.] (updateable thunk only) %Todo: forward ref.
4018 \item[Push update frame.]
4019 \item[Evaluate body of closure.]
4023 \Subsection{Case expressions and return conventions}{return-conventions}
4025 The \emph{evaluation} of a thunk is always initiated by
4026 a @case@ expression. For example:
4028 case x of (a,b) -> E
4031 The code for a @case@ expression looks like this:
4034 \item Push the free variables of the branches on the stack (fv(@E@) in
4036 \item Push a \emph{return address} on the stack.
4037 \item Evaluate the scrutinee (@x@ in this case).
4040 Once evaluation of the scrutinee is complete, execution resumes at the
4041 return address, which points to the code for the expression @E@.
4043 When execution resumes at the return point, there must be some {\em
4044 return convention} that defines where the components of the pair, @a@
4045 and @b@, can be found. The return convention varies according to the
4046 type of the scrutinee @x@:
4052 (A space for) the return address is left on the top of the stack.
4053 Leaving the return address on the stack ensures that the top of the
4054 stack contains a valid activation record
4055 (\secref{activation-records}) --- should a garbage
4056 collection be required.
4058 \item If @x@ has a boxed type (e.g.~a data constructor or a function),
4059 a pointer to @x@ is returned in \Arg{1}.
4061 \ToDo{Warn that components of E should be extracted as soon as
4062 possible to avoid a space leak.}
4064 \item If @x@ is an unboxed type (e.g.~@Int#@ or @Float#@), @x@ is
4067 \item If @x@ is an unboxed tuple constructor, the components of @x@
4068 are returned in \Arg{1} \ldots \Arg{n} but no object is constructed in
4071 When passing an unboxed tuple to a function, the components are
4072 flattened out and passed in \Arg{1} \ldots \Arg{n} as usual.
4076 \Subsection{Vectored Returns}{vectored-returns}
4078 Many algebraic data types have more than one constructor. For
4079 example, the @Maybe@ type is defined like this:
4081 data Maybe a = Nothing | Just a
4083 How does the return convention encode which of the two constructors is
4084 being returned? A @case@ expression scrutinising a value of @Maybe@
4085 type would look like this:
4091 Rather than pushing a return address before evaluating the scrutinee,
4092 @E@, the @case@ expression pushes (a pointer to) a \emph{return
4093 vector}, a static table consisting of two code pointers: one for the
4094 @Just@ alternative, and one for the @Nothing@ alternative.
4100 The constructor @Nothing@ returns by jumping to the first item in the
4101 return vector with a pointer to a (statically built) Nothing closure
4104 It might seem that we could avoid loading \Arg{1} in this case since the
4105 first item in the return vector will know that @Nothing@ was returned
4106 (and can easily access the Nothing closure in the (unlikely) event
4107 that it needs it. The only reason we load \Arg{1} is in case we have to
4108 perform an update (\secref{data-updates}).
4112 The constructor @Just@ returns by jumping to the second element of the
4113 return vector with a pointer to the closure in \Arg{1}.
4117 In this way no test need be made to see which constructor returns;
4118 instead, execution resumes immediately in the appropriate branch of
4121 \Subsection{Direct Returns}{direct-returns}
4123 When a datatype has a large number of constructors, it may be
4124 inappropriate to use vectored returns. The vector tables may be
4125 large and sparse, and it may be better to identify the constructor
4126 using a test-and-branch sequence on the tag. For this reason, we
4127 provide an alternative return convention, called a \emph{direct
4130 In a direct return, the return address pushed on the stack really is a
4131 code pointer. The returning code loads a pointer to the closure being
4132 returned in \Arg{1} as usual, and also loads the tag into \Arg{2}.
4133 The code at the return address will test the tag and jump to the
4134 appropriate code for the case branch. If \Arg{2} isn't mapped to a
4135 real machine register on this architecture, then we don't load it on a
4136 return, instead using the tag directly from the info table.
4138 The choice of whether to use a vectored return or a direct return is
4139 made on a type-by-type basis --- up to a certain maximum number of
4140 constructors imposed by the update mechanism
4141 (\secref{data-updates}).
4143 Single-constructor data types also use direct returns, although in
4144 that case there is no need to return a tag in \Arg{2}.
4146 \ToDo{for a nullary constructor we needn't return a pointer to the
4147 constructor in \Arg{1}.}
4149 \Subsection{Updates}{data-updates}
4151 The entry code for an updatable thunk (which must be of arity 0):
4154 \item copies the free variables out of the thunk into registers or
4156 \item pushes an \emph{update frame} onto the stack.
4158 An update frame is a small activation record consisting of
4160 \begin{tabular}{|l|l|l|}
4162 \emph{Fixed header} & \emph{Update Frame link} & \emph{Updatee} \\
4167 \note{In the semantics part of the STG paper (section 5.6), an update
4168 frame consists of everything down to the last update frame on the
4169 stack. This would make sense too --- and would fit in nicely with
4170 what we're going to do when we add support for speculative
4172 \ToDo{I think update frames contain cost centres sometimes}
4174 \item If we are doing ``eager blackholing,'' we then overwrite the
4175 thunk with a black hole (\secref{BLACKHOLE}). Otherwise, we leave it
4176 to the garbage collector to black hole the thunk.
4179 Start evaluating the body of the expression.
4183 When the expression finishes evaluation, it will enter the update
4184 frame on the top of the stack. Since the returner doesn't know
4185 whether it is entering a normal return address/vector or an update
4186 frame, we follow exactly the same conventions as return addresses and
4187 return vectors. That is, on entering the update frame:
4190 \item The value of the thunk is in \Arg{1}. (Recall that only thunks
4191 are updateable and that thunks return just one value.)
4193 \item If the data type is a direct-return type rather than a
4194 vectored-return type, then the tag is in \Arg{2}.
4196 \item The update frame is still on the stack.
4199 We can safely share a single statically-compiled update function
4200 between all types. However, the code must be able to handle both
4201 vectored and direct-return datatypes. This is done by arranging that
4202 the update code looks like this:
4210 |---------------| <- update code pointer
4215 Each entry in the return vector (which is large enough to cover the
4216 largest vectored-return type) points to the update code.
4220 \item overwrites the \emph{updatee} with an indirection to \Arg{1};
4221 \item loads @Su@ from the Update Frame link;
4222 \item removes the update frame from the stack; and
4223 \item enters \Arg{1}.
4226 We enter \Arg{1} again, having probably just come from there, because
4227 it knows whether to perform a direct or vectored return. This could
4228 be optimised by compiling special update code for each slot in the
4229 return vector, which performs the correct return.
4231 \Subsection{Semi-tagging}{semi-tagging}
4233 When a @case@ expression evaluates a variable that might be bound
4234 to a thunk it is often the case that the scrutinee is already evaluated.
4235 In this case we have paid the penalty of (a) pushing the return address (or
4236 return vector address) on the stack, (b) jumping through the info pointer
4237 of the scrutinee, and (c) returning by an indirect jump through the
4238 return address on the stack.
4240 If we knew that the scrutinee was already evaluated we could generate
4241 (better) code which simply jumps to the appropriate branch of the
4242 @case@ with a pointer to the scrutinee in \Arg{1}. (For direct
4243 returns to multiconstructor datatypes, we might also load the tag into
4246 An obvious idea, therefore, is to test dynamically whether the heap
4247 closure is a value (using the tag in the info table). If not, we
4248 enter the closure as usual; if so, we jump straight to the appropriate
4249 alternative. Here, for example, is pseudo-code for the expression
4250 @(case x of { (a,_,c) -> E }@:
4252 \Arg{1} = <pointer to x>;
4253 tag = \Arg{1}->entry->tag;
4255 Sp--; \\ insert space for return address
4259 goto \Arg{1}->entry;
4261 <info table for return address goes here>
4262 ret: a = \Arg{1}->data1; \\ suck out a and c to avoid space leak
4266 and here is the code for the expression @(case x of { [] -> E1; x:xs -> E2 }@:
4268 \Arg{1} = <pointer to x>;
4269 tag = \Arg{1}->entry->tag;
4271 Sp--; \\ insert space for return address
4275 goto \Arg{1}->entry;
4279 retvec: \\ reversed return vector
4280 <return info table for case goes here>
4282 panic("Direct return into vectored case");
4286 ret2: x = \Arg{1}->head;
4290 There is an obvious cost in compiled code size (but none in the size
4291 of the bytecodes). There is also a cost in execution time if we enter
4292 more thunks than data constructors.
4294 Both the direct and vectored returns are easily modified to chase chains
4295 of indirections too. In the vectored case, this is most easily done by
4296 making sure that @IND = TAG_1 - 1@, and adding an extra field to every
4297 return vector. In the above example, the indirection code would be
4299 ind: \Arg{1} = \Arg{1}->next;
4302 where @ind_loop@ is the second line of code.
4304 Note that we have to leave space for a return address since the return
4305 address expects to find one. If the body of the expression requires a
4306 heap check, we will actually have to write the return address before
4307 entering the garbage collector.
4310 \Subsection{Heap and Stack Checks}{heap-and-stack-checks}
4312 The storage manager detects that it needs to garbage collect the old
4313 generation when the evaluator requests a garbage collection without
4314 having moved the heap pointer since the last garbage collection. It
4315 is therefore important that the GC routines \emph{not} move the heap
4316 pointer unless the heap check fails. This is different from what
4317 happens in the current STG implementation.
4319 Assuming that the stack can never shrink, we perform a stack check
4320 when we enter a closure but not when we return to a return
4321 continuation. This doesn't work for heap checks because we cannot
4322 predict what will happen to the heap if we call a function.
4324 If we wish to allow the stack to shrink, we need to perform a stack
4325 check whenever we enter a return continuation. Most of these checks
4326 could be eliminated if the storage manager guaranteed that a stack
4327 would always have 1000 words (say) of space after it was shrunk. Then
4328 we can omit stack checks for less than 1000 words in return
4331 When an argument satisfaction check fails, we need to push the closure
4332 (in R1) onto the stack - so we need to perform a stack check. The
4333 problem is that the argument satisfaction check occurs \emph{before}
4334 the stack check. The solution is that the caller of a slow entry
4335 point or closure will guarantee that there is at least one word free
4336 on the stack for the callee to use.
4338 Similarily, if a heap or stack check fails, we need to push the arguments
4339 and closure onto the stack. If we just came from the slow entry point,
4340 there's certainly enough space and it is the responsibility of anyone
4341 using the fast entry point to guarantee that there is enough space.
4343 \ToDo{Be more precise about how much space is required - document it
4344 in the calling convention section.}
4346 \Subsection{Handling interrupts/signals}{signals}
4349 May have to keep C stack pointer in register to placate OS?
4350 May have to revert black holes - ouch!
4355 \section{The Loader}
4356 \section{The Compilers}
4359 \part{Old stuff - needs to be mined for useful info}
4361 \section{The Scheduler}
4363 The Scheduler is the heart of the run-time system. A running program
4364 consists of a single running thread, and a list of runnable and
4365 blocked threads. The running thread returns to the scheduler when any
4366 of the following conditions arises:
4369 \item A heap check fails, and a garbage collection is required
4370 \item Compiled code needs to switch to interpreted code, and vice
4372 \item The thread becomes blocked.
4373 \item The thread is preempted.
4376 A running system has a global state, consisting of
4379 \item @Hp@, the current heap pointer, which points to the next
4380 available address in the Heap.
4381 \item @HpLim@, the heap limit pointer, which points to the end of the
4383 \item The Thread Preemption Flag, which is set whenever the currently
4384 running thread should be preempted at the next opportunity.
4385 \item A list of runnable threads.
4386 \item A list of blocked threads.
4389 Each thread is represented by a Thread State Object (TSO), which is
4390 described in detail in \secref{TSO}.
4392 The following is pseudo-code for the inner loop of the scheduler
4396 while (threads_exist) {
4397 // handle global problems: GC, parallelism, etc
4399 if (external_message) service_message();
4400 // deal with other urgent stuff
4402 pick a runnable thread;
4404 // enter object on top of stack
4405 // if the top object is a BCO, we must enter it
4406 // otherwise appply any heuristic we wish.
4407 if (thread->stack[thread->sp]->info.type == BCO) {
4408 status = runHugs(thread,&smInfo);
4410 status = runGHC(thread,&smInfo);
4412 switch (status) { // handle local problems
4413 case (StackOverflow): enlargeStack; break;
4414 case (Error e) : error(thread,e); break;
4415 case (ExitWith e) : exit(e); break;
4416 case (Yield) : break;
4418 } while (thread_runnable);
4422 \Subsection{Invoking the garbage collector}{ghc-invoking-gc}
4424 \Subsection{Putting the thread to sleep}{ghc-thread-sleeps}
4426 \Subsection{Calling C from Haskell}{ghc-ccall}
4428 We distinguish between "safe calls" where the programmer guarantees
4429 that the C function will not call a Haskell function or, in a
4430 multithreaded system, block for a long period of time and "unsafe
4431 calls" where the programmer cannot make that guarantee.
4433 Safe calls are performed without returning to the scheduler and are
4434 discussed elsewhere (\ToDo{discuss elsewhere}).
4436 Unsafe calls are performed by returning an array (outside the Haskell
4437 heap) of arguments and a C function pointer to the scheduler. The
4438 scheduler allocates a new thread from the operating system
4439 (multithreaded system only), spawns a call to the function and
4440 continues executing another thread. When the ccall completes, the
4441 thread informs the scheduler and the scheduler adds the thread to the
4442 runnable threads list.
4444 \ToDo{Describe this in more detail.}
4447 \Subsection{Calling Haskell from C}{ghc-c-calls-haskell}
4449 When C calls a Haskell closure, it sends a message to the scheduler
4450 thread. On receiving the message, the scheduler creates a new Haskell
4451 thread, pushes the arguments to the C function onto the thread's stack
4452 (with tags for unboxed arguments) pushes the Haskell closure and adds
4453 the thread to the runnable list so that it can be entered in the
4456 When the closure returns, the scheduler sends back a message which
4457 awakens the (C) thread.
4459 \ToDo{Do we need to worry about the garbage collector deallocating the
4460 thread if it gets blocked?}
4462 \Subsection{Switching Worlds}{switching-worlds}
4464 \ToDo{This has all changed: we always leave a closure on top of the
4465 stack if we mean to continue executing it. The scheduler examines the
4466 top of the stack and tries to guess which world we want to be in. If
4467 it finds a @BCO@, it certainly enters Hugs, if it finds a @GHC@
4468 closure, it certainly enters GHC and if it finds a standard closure,
4469 it is free to choose either one but it's probably best to enter GHC
4470 for everything except @BCO@s and perhaps @AP@s.}
4472 Because this is a combined compiled/interpreted system, the
4473 interpreter will sometimes encounter compiled code, and vice-versa.
4475 All world-switches go via the scheduler, ensuring that the world is in
4476 a known state ready to enter either compiled code or the interpreter.
4477 When a thread is run from the scheduler, the @whatNext@ field in the
4478 TSO (\secref{TSO}) is checked to find out how to execute the
4482 \item If @whatNext@ is set to @ReturnGHC@, we load up the required
4483 registers from the TSO and jump to the address at the top of the user
4485 \item If @whatNext@ is set to @EnterGHC@, we load up the required
4486 registers from the TSO and enter the closure pointed to by the top
4488 \item If @whatNext@ is set to @EnterHugs@, we enter the top thing on
4489 the stack, using the interpreter.
4492 There are four cases we need to consider:
4495 \item A GHC thread enters a Hugs-built closure.
4496 \item A GHC thread returns to a Hugs-compiled return address.
4497 \item A Hugs thread enters a GHC-built closure.
4498 \item A Hugs thread returns to a Hugs-compiled return address.
4501 GHC-compiled modules cannot call functions in a Hugs-compiled module
4502 directly, because the compiler has no information about arities in the
4503 external module. Therefore it must assume any top-level objects are
4504 CAFs, and enter their closures.
4506 \ToDo{Hugs-built constructors?}
4508 We now examine the various cases one by one and describe how the
4509 switch happens in each situation.
4511 \subsection{A GHC thread enters a Hugs-built closure}
4512 \label{sec:ghc-to-hugs-switch}
4514 There is three possibilities: GHC has entered a @PAP@, or it has
4515 entered a @AP@, or it has entered the BCO directly (for a top-level
4516 function closure). @AP@s and @PAP@s are ``standard closures'' and
4517 so do not require us to enter the bytecode interpreter.
4519 The entry code for a BCO does the following:
4522 \item Push the address of the object entered on the stack.
4523 \item Save the current state of the thread in its TSO.
4524 \item Return to the scheduler, setting @whatNext@ to @EnterHugs@.
4527 BCO's for thunks and functions have the same entry conventions as
4528 slow entry points: they expect to find their arguments on the stac
4529 with unboxed arguments preceded by appropriate tags.
4531 \subsection{A GHC thread returns to a Hugs-compiled return address}
4532 \label{sec:ghc-to-hugs-switch}
4534 Hugs return addresses are laid out as in \figref{hugs-return-stack}.
4535 If GHC is returning, it will return to the address at the top of the
4536 stack, namely @HUGS_RET@. The code at @HUGS_RET@ performs the
4540 \item pushes \Arg{1} (the return value) on the stack.
4541 \item saves the thread state in the TSO
4542 \item returns to the scheduler with @whatNext@ set to @EnterHugs@.
4545 \noindent When Hugs runs, it will enter the return value, which will
4546 return using the correct Hugs convention
4547 (\secref{hugs-return-convention}) to the return address underneath it
4550 \subsection{A Hugs thread enters a GHC-compiled closure}
4551 \label{sec:hugs-to-ghc-switch}
4553 Hugs can recognise a GHC-built closure as not being one of the
4554 following types of object:
4560 \item An indirection, or
4561 \item A constructor.
4564 When Hugs is called on to enter a GHC closure, it executes the
4565 following sequence of instructions:
4568 \item Push the address of the closure on the stack.
4569 \item Save the current state of the thread in the TSO.
4570 \item Return to the scheduler, with the @whatNext@ field set to
4574 \subsection{A Hugs thread returns to a GHC-compiled return address}
4575 \label{sec:hugs-to-ghc-switch}
4577 When Hugs encounters a return address on the stack that is not
4578 @HUGS_RET@, it knows that a world-switch is required. At this point
4579 the stack contains a pointer to the return value, followed by the GHC
4580 return address. The following sequence is then performed:
4583 \item save the state of the thread in the TSO.
4584 \item return to the scheduler, setting @whatNext@ to @EnterGHC@.
4587 The first thing that GHC will do is enter the object on the top of the
4588 stack, which is a pointer to the return value. This value will then
4589 return itself to the return address using the GHC return convention.
4597 We're nuking the following:
4604 Return in registers.
4605 This lets us remove update code pointers from info tables,
4606 removes the need for phantom info tables, simplifies
4611 Careful analysis suggests that it doesn't buy us very much
4612 and it is hard to work with.
4614 Eliminating threaded GCs eliminates the desire to share SMReps
4615 so they are (once more) part of the Info table.
4619 Doesn't buy us anything on a register-poor architecture and
4620 isn't so important if we have semi-tagging.
4623 - Probably bad on register poor architecture
4624 - Can avoid need to write return address to stack on reg rich arch.
4625 - when a function does a small amount of work, doesn't
4626 enter any other thunks and then returns.
4627 eg entering a known constructor (but semitagging will catch this)
4628 - Adds complications
4634 This lets us drop CONST closures and CHARLIKE closures (assuming we
4635 don't support Unicode). The only point of these closures was to
4636 avoid updating with an indirection.
4638 We also drop @MIN_UPD_SIZE@ --- all we need is space to insert an
4639 indirection or a black hole.
4642 STATIC SMReps are now called CONST
4647 \item The profiling ``kind'' field is now encoded in the @INFO_TYPE@ field.
4648 This identifies the general sort of the closure for profiling purposes.
4650 \item Various papers describe deleting update frames for unreachable objects.
4651 This has never been implemented and we don't plan to anytime soon.