[project @ 1997-10-21 17:22:24 by reid]
[ghc.git] / docs / rts / rts.verb
1 %
2 % (c) The OBFUSCATION-THROUGH-GRATUITOUS-PREPROCESSOR-ABUSE Project,
3 %     Glasgow University, 1990-1994
4 %
5
6 % TODO:
7 %
8 % o I think it would be worth making the connection with CPS explicit.
9 %   Now that we have explicit activation records (on the stack), we can
10 %   explain the whole system in terms of CPS and tail calls --- with the
11 %   one requirement that we carefuly distinguish stack-allocated objects
12 %   from heap-allocated objects.
13
14
15 % \documentstyle[preprint]{acmconf}
16 \documentclass[11pt]{article}
17 \oddsidemargin 0.1 in       %   Note that \oddsidemargin = \evensidemargin
18 \evensidemargin 0.1 in
19 \marginparwidth 0.85in    %   Narrow margins require narrower marginal notes
20 \marginparsep 0 in 
21 \sloppy
22
23 \usepackage{epsfig}
24
25 \newcommand{\note}[1]{{\em Note: #1}}
26 % DIMENSION OF TEXT:
27 \textheight 8.5 in
28 \textwidth 6.25 in
29
30 \topmargin 0 in
31 \headheight 0 in
32 \headsep .25 in
33
34
35 \setlength{\parskip}{0.15cm}
36 \setlength{\parsep}{0.15cm}
37 \setlength{\topsep}{0cm}        % Reduces space before and after verbatim,
38                                 % which is implemented using trivlist 
39 \setlength{\parindent}{0cm}
40
41 \renewcommand{\textfraction}{0.2}
42 \renewcommand{\floatpagefraction}{0.7}
43
44 \begin{document}
45
46 \newcommand{\ToDo}[1]{{{\bf ToDo:}\sl #1}}
47 \newcommand{\Arg}[1]{\mbox{${\tt arg}_{#1}$}}
48 \newcommand{\bottom}{bottom} % foo, can't remember the symbol name
49
50 \title{The STG runtime system (revised)}
51 \author{Simon Peyton Jones \\ Glasgow University and Oregon Graduate Institute \and
52 Simon Marlow \\ Glasgow University \and
53 Alastair Reid \\ Yale University} 
54
55 \maketitle
56
57 \tableofcontents
58 \newpage
59
60 \part{Introduction}
61 \section{Overview}
62
63 This document describes the GHC/Hugs run-time system.  It serves as 
64 a Glasgow/Yale/Nottingham ``contract'' about what the RTS does.
65
66 \subsection{New features compared to GHC 2.04}
67
68 \begin{itemize}
69 \item The RTS supports mixed compiled/interpreted execution, so
70 that a program can consist of a mixture of GHC-compiled and Hugs-interpreted
71 code.
72
73 \item CAFs are only retained if they are
74 reachable.  Since they are referred to by implicit references buried
75 in code, this means that the garbage collector must traverse the whole
76 accessible code tree.  This feature eliminates a whole class of painful
77 space leaks.
78
79 \item A running thread has only one stack, which contains a mixture
80 of pointers and non-pointers.  Section~\ref{sect:stacks} describes how
81 we find out which is which.  (GHC has used two stacks for some while.
82 Using one stack instead of two reduces register pressure, reduces the
83 size of update frames, and eliminates
84 ``stack-stubbing'' instructions.)
85
86 \item The ``return in registers'' return convention has been dropped
87 because it was complicated and doesn't work well on register-poor
88 architectures.  It has been partly replaced by unboxed
89 tuples~\ref{sect:unboxed-tuples} which allow the programmer to
90 explicitly state where results should be returned in registers (or on
91 the stack) instead of on the heap.
92
93 \end{itemize} 
94
95 \subsection{Wish list}
96
97 Here's a list of things we'd like to support in the future.
98 \begin{itemize}
99 \item Interrupts, speculative computation.
100
101 \item
102 The SM could tune the size of the allocation arena, the number of
103 generations, etc taking into account residency, GC rate and page fault
104 rate.
105
106 \item
107 There should be no need to specify the amnount of stack/heap space to
108 allocate when you started a program - let it just take as much or as
109 little as it wants.  (It might be useful to be able to specify maximum
110 sizes and to be able to suggest an initial size.)
111
112 \item 
113 We could trigger a GC when all threads are blocked waiting for IO if
114 the allocation arena (or some of the generations) are nearly full.
115
116 \end{itemize}
117
118 \subsection{Configuration}
119
120 Some of the above features are expensive or less portable, so we
121 envision building a number of different configurations supporting
122 different subsets of the above features.
123
124 You can make the following choices:
125 \begin{itemize}
126 \item
127 Support for concurrency or parallelism.  There are four 
128 mutually-exclusive choices.
129
130 \begin{description}
131 \item[@SEQUENTIAL@] No concurrency or parallelism support.
132   This configuration might not support interrupt recovery.
133 \item[@CONCURRENT@]  Support for concurrency but not for parallelism.
134 \item[@CONCURRENT@+@GRANSIM@] Concurrency support and simulated parallelism.
135 \item[@CONCURRENT@+@PARALLEL@]     Concurrency support and real parallelism.
136 \end{description}
137
138 \item @PROFILING@ adds cost-centre profiling.
139
140 \item @TICKY@ gathers internal statistics (often known as ``ticky-ticky'' code).
141
142 \item @DEBUG@ does internal consistency checks.
143
144 \item Persistence. (well, not yet).
145
146 \item
147 Which garbage collector to use.  At the moment we
148 only anticipate one, however.
149 \end{itemize}
150
151 \subsection{Glossary}
152
153 \ToDo{This terminology is not used consistently within the document.
154 If you find soemthing which disagrees with this terminology, fix the
155 usage.}
156
157 \begin{itemize}
158
159 \item A {\em word} is (at least) 32 bits and can hold either a signed
160 or an unsigned int.
161
162 \item A {\em pointer} is (at least) 32 bits and big enough to hold a
163 function pointer or a data pointer.  
164
165 \item A {\em boxed} type is one whose elements are heap allocated.
166
167 \item An {\em unboxed} type is one whose elements are {\em not} heap allocated.
168
169 \item A {\em pointed} type is one that contains $\bot$.  Variables with
170 pointed types are the only things which can be lazily evaluated.  In
171 the STG machine, this means that they are the only things that can be 
172 {\em entered} or {\em updated} and it requires that they be boxed.
173
174 \item An {\em unpointed} type is one that does not contains $\bot$.
175 Variables with unpointed types are never delayed --- they are always
176 evaluated when they are constructed.  In the STG machine, this means
177 that they cannot be {\em entered} or {\em updated}.  Unpointed objects
178 may be boxed (like @Array#@) or unboxed (like @Int#@).
179
180 \item A {\em closure} is a (representation of) a value of a {\em pointed}
181 type.  It may be in HNF or it may be unevaluated --- in either case, you can
182 try to evaluate it again.
183
184 \item A {\em thunk} is a (representation of) a value of a {\em pointed}
185 type which is {\em not} in HNF.
186
187 \item A {\em value} is an object in HNF.  It can be pointed or unpointed.
188
189 \end{itemize}
190
191 Occasionally, a field of a data structure must hold either a word or a
192 pointer.  In such circumstances, it is {\em not safe} to assume that
193 words and pointers are the same size.
194
195 % Todo:
196 % More terminology to mention.
197 % unboxed, unpointed
198
199 \subsection{Invariants}
200
201 There are a few system invariants which need to be mentioned ---
202 though this is probably the wrong place for them.
203
204 \begin{itemize}
205
206 \item The garbage collector never expands an object when it promotes
207 it to the old generation.  This is important because the GC avoids
208 performing heap overflow checks by assuming that the amount added to
209 the old generation is no bigger than the current new generation.
210
211 \end{itemize}
212
213 \section{Source Language}
214
215 \subsection{Unboxed tuples}\label{sect:unboxed-tuples}
216
217 Functions can take multiple arguments as easily as they can take one
218 argument: there's no cost for adding another argument.  But functions
219 can only return one result: the cost of adding a second ``result'' is
220 that the function must construct a tuple of ``results'' on the heap.
221 The assymetry is rather galling and can make certain programming
222 styles quite expensive.  For example, consider a simple state transformer
223 monad:
224 @
225 > type S a = State -> (a,State)
226 > bindS m k s0 = case m s0 of { (a,s1) -> k a s1 }
227 > returnS a s  = (a,s)
228 > getS s       = (s,s)
229 > setS s _     = ((),s)
230 @
231 Here, every use of @returnS@, @getS@ or @setS@ constructs a new tuple
232 in the heap which is instantly taken apart (and becomes garbage) by
233 the case analysis in @bind@.  Even a short state-transformer program
234 will construct a lot of these temporary tuples.
235
236 Unboxed tuples provide a way for the programmer to indicate that they
237 do not expect a tuple to be shared and that they do not expect it to
238 be allocated in the heap.  Syntactically, unboxed tuples are just like
239 single constructor datatypes except for the annotation @unboxed@.
240 @
241 > data unboxed AAndState# a = AnS a State
242 > type S a = State -> AAndState# a
243 > bindS m k s0 = case m s0 of { AnS a s1 -> k a s1 }
244 > returnS a s  = AnS a s
245 > getS s       = AnS s s
246 > setS s _     = AnS () s
247 @
248 Semantically, unboxed tuples are just unlifted tuples and are subject
249 to the same restrictions as other unpointed types.
250
251 Operationally, unboxed tuples are never built on the heap.  When
252 unboxed tuples are returned, they are returned in multiple registers
253 or multiple stack slots.  At first sight, this seems a little strange
254 but it's no different from passing double precision floats in two
255 registers.
256
257 Note that unboxed tuples can only have one constructor and that
258 thunks never have unboxed types --- so we'll never try to update an
259 unboxed constructor.  The restriction to a single constructor is
260 largely to avoid garbage collection complications.
261
262
263 %-----------------------------------------------------------------------------
264 \part{Evaluation Model}
265 \section{Compiled Execution}
266
267 This section describes the framework in which compiled code evaluates
268 expressions.  Only at certain points will compiled code need to be
269 able to talk to the interpreted world; these are discussed in Section
270 \ref{sect:switching-worlds}.
271
272 \subsection{Calling conventions}
273
274 \subsubsection{The call/return registers}
275
276 One of the problems in designing a virtual machine is that we want it
277 abstract away from tedious machine details but still reveal enough of
278 the underlying hardware that we can make sensible decisions about code
279 generation.  A major problem area is the use of registers in
280 call/return conventions.  On a machine with lots of registers, it's
281 cheaper to pass arguments and results in registers than to pass them
282 on the stack.  On a machine with very few registers, it's cheaper to
283 pass arguments and results on the stack than to use ``virtual
284 registers'' in memory.  We therefore use a hybrid system: the first
285 $n$ arguments or results are passed in registers; and the remaining
286 arguments or results are passed on the stack.  For register-poor
287 architectures, it is important that we allow $n=0$.
288
289 We'll label the arguments and results \Arg{1} \ldots \Arg{m} --- with
290 the understanding that \Arg{1} \ldots \Arg{n} are in registers and
291 \Arg{n+1} \ldots \Arg{m} are on top of the stack.
292
293 Note that the mapping of arguments \Arg{1} \ldots \Arg{n} to machine
294 registers depends on the {\em kinds} of the arguments.  For example,
295 if the first argument is a Float, we might pass it in a different
296 register from if it is an Int.  In fact, we might find that a given
297 architecture lets us pass varying numbers of arguments according to
298 their types.  For example, if a CPU has 2 Int registers and 2 Float
299 registers then we could pass between 2 and 4 arguments in machine
300 registers --- depending on whether they all have the same kind or they
301 have different kinds.
302
303 \subsubsection{Entering closures}
304
305 To evaluate a closure we jump to the entry code for the closure
306 passing a pointer to the closure in \Arg{1} so that the entry code can
307 access its environment.
308
309 \subsubsection{Function call}
310
311 The function-call mechanism is obviously crucial.  There are five different
312 cases to consider:
313 \begin{enumerate}
314
315 \item {\em Known combinator (function with no free variables) and enough arguments.}  
316
317 A fast call can be made: push excess arguments onto stack and jump to
318 function's {\em fast entry point} passing arguments in \Arg{1} \ldots
319 \Arg{m}.  
320
321 The {\em fast entry point} is only called with exactly the right
322 number of arguments (in \Arg{1} \ldots \Arg{m}) so it can instantly
323 start doing useful work without first testing whether it has enough
324 registers or having to pop them off the stack first.
325
326 \item {\em Known combinator and insufficient arguments.}
327
328 A slow call can be made: push all arguments onto stack and jump to
329 function's {\em slow entry point}.
330
331 Any unpointed arguments which are pushed on the stack must be tagged.
332 This means pushing an extra word on the stack below the unpointed
333 words, containing the number of unpointed words above it.
334
335 %Todo: forward ref about tagging?
336 %Todo: picture?
337
338 The {\em slow entry point} might be called with insufficient arguments
339 and so it must test whether there are enough arguments on the stack.
340 This {\em argument satisfaction check} consists of checking that
341 @Su-Sp@ is big enough to hold all the arguments (including any tags).
342
343 \begin{itemize} 
344
345 \item If the argument satisfaction check fails, it is because there is
346 one or more update frames on the stack before the rest of the
347 arguments that the function needs.  In this case, we construct a PAP
348 (partial application, section~\ref{sect:PAP}) containing the arguments
349 which are on the stack.  The PAP construction code will return to the
350 update frame with the address of the PAP in \Arg{1}.
351
352 \item If the argument satisfaction check succeeds, we jump to the fast
353 entry point with the arguments in \Arg{1} \ldots \Arg{arity}.
354
355 If the fast entry point expects to receive some of \Arg{i} on the
356 stack, we can reduce the amount of movement required by making the
357 stack layout for the fast entry point look like the stack layout for
358 the slow entry point.  Since the slow entry point is entered with the
359 first argument on the top of the stack and with tags in front of any
360 unpointed arguments, this means that if \Arg{i} is unpointed, there
361 should be space below it for a tag and that the highest numbered
362 argument should be passed on the top of the stack.
363
364 We usually arrange that the fast entry point is placed immediately
365 after the slow entry point --- so we can just ``fall through'' to the
366 fast entry point without performing a jump.
367
368 \end{itemize}
369
370
371 \item {\em Known function closure (function with free variables) and enough arguments.}
372
373 A fast call can be made: push excess arguments onto stack and jump to
374 function's {\em fast entry point} passing a pointer to closure in
375 \Arg{1} and arguments in \Arg{2} \ldots \Arg{m+1}.
376
377 Like the fast entry point for a combinator, the fast entry point for a
378 closure is only called with appropriate values in \Arg{1} \ldots
379 \Arg{m+1} so we can start work straight away.  The pointer to the
380 closure is used to access the free variables of the closure.
381
382
383 \item {\em Known function closure and insufficient arguments.}
384
385 A slow call can be made: push all arguments onto stack and jump to the
386 closure's slow entry point passing a pointer to the closure in \Arg{1}.
387
388 Again, the slow entry point performs an argument satisfaction check
389 and either builds a PAP or pops the arguments off the stack into
390 \Arg{2} \ldots \Arg{m+1} and jumps to the fast entry point.
391
392
393 \item {\em Unknown function closure, thunk or constructor.}
394
395 Sometimes, the function being called is not statically identifiable.
396 Consider, for example, the @compose@ function:
397 @
398   compose f g x = f (g x)
399 @
400 Since @f@ and @g@ are passed as arguments to @compose@, the latter has
401 to make a heap call.  In a heap call the arguments are pushed onto the
402 stack, and the closure bound to the function is entered.  In the
403 example, a thunk for @(g x)@ will be allocated, (a pointer to it)
404 pushed on the stack, and the closure bound to @f@ will be
405 entered. That is, we will jump to @f@s entry point passing @f@ in
406 \Arg{1}.  If \Arg{1} is passed on the stack, it is pushed on top of
407 the thunk for @(g x)@.
408
409 The {\em entry code} for an updateable thunk (which must have arity 0)
410 pushes an update frame on the stack and starts executing the body of
411 the closure --- using \Arg{1} to access any free variables.  This is
412 described in more detail in section~\ref{sect:data-updates}.
413
414 The {\em entry code} for a non-updateable closure is just the
415 closure's slow entry point.
416
417 \end{enumerate}
418
419 In addition to the above considerations, if there are \emph{too many}
420 arguments then the extra arguments are simply pushed on the stack with
421 appropriate tags.
422
423 To summarise, a closure's standard (slow) entry point performs the following:
424 \begin{description}
425 \item[Argument satisfaction check.] (function closure only)
426 \item[Stack overflow check.]
427 \item[Heap overflow check.]
428 \item[Copy free variables out of closure.] %Todo: why?
429 \item[Eager black holing.] (updateable thunk only) %Todo: forward ref.
430 \item[Push update frame.]
431 \item[Evaluate body of closure.]
432 \end{description}
433
434
435 \subsection{Case expressions and return conventions}
436 \label{sect:return-conventions}
437
438 The {\em evaluation} of a thunk is always initiated by
439 a @case@ expression.  For example:
440 @
441   case x of (a,b) -> E
442 @
443
444 The code for a @case@ expression looks like this:
445
446 \begin{itemize}
447 \item Push the free variables of the branches on the stack (fv(@E@) in
448 this case).
449 \item  Push a \emph{return address} on the stack.
450 \item  Evaluate the scrutinee (@x@ in this case).
451 \end{itemize}
452
453 Once evaluation of the scrutinee is complete, execution resumes at the
454 return address, which points to the code for the expression @E@.
455
456 When execution resumes at the return point, there must be some {\em
457 return convention} that defines where the components of the pair, @a@
458 and @b@, can be found.  The return convention varies according to the
459 type of the scrutinee @x@:
460
461 \begin{itemize}
462
463 \item 
464
465 (A space for) the return address is left on the top of the stack.
466 Leaving the return address on the stack ensures that the top of the
467 stack contains a valid activation record
468 (section~\ref{sect:activation-records}) --- should a garbage collection
469 be required.
470
471 \item If @x@ has a boxed type (e.g.~a data constructor or a function),
472 a pointer to @x@ is returned in \Arg{1}.
473
474 \ToDo{Warn that components of E should be extracted as soon as
475 possible to avoid a space leak.}
476
477 \item If @x@ is an unboxed type (e.g.~@Int#@ or @Float#@), @x@ is
478 returned in \Arg{1}
479
480 \item If @x@ is an unboxed tuple constructor, the components of @x@
481 are returned in \Arg{1} \ldots \Arg{n} but no object is constructed in
482 the heap.  
483
484 When passing an unboxed tuple to a function, the components are
485 flattened out and passed in \Arg{1} \ldots \Arg{n} as usual.
486
487 \end{itemize}
488
489 \subsection{Vectored Returns}
490
491 Many algebraic data types have more than one constructor.  For
492 example, the @Maybe@ type is defined like this:
493 @
494   data Maybe a = Nothing | Just a
495 @
496 How does the return convention encode which of the two constructors is
497 being returned?  A @case@ expression scrutinising a value of @Maybe@
498 type would look like this: 
499 @
500   case E of 
501     Nothing -> ...
502     Just a  -> ...
503 @
504 Rather than pushing a return address before evaluating the scrutinee,
505 @E@, the @case@ expression pushes (a pointer to) a {\em return
506 vector}, a static table consisting of two code pointers: one for the
507 @Just@ alternative, and one for the @Nothing@ alternative.  
508
509 \begin{itemize}
510
511 \item
512
513 The constructor @Nothing@ returns by jumping to the first item in the
514 return vector with a pointer to a (statically built) Nothing closure
515 in \Arg{1}.  
516
517 It might seem that we could avoid loading \Arg{1} in this case since the
518 first item in the return vector will know that @Nothing@ was returned
519 (and can easily access the Nothing closure in the (unlikely) event
520 that it needs it.  The only reason we load \Arg{1} is in case we have to
521 perform an update (section~\ref{sect:data-updates}).
522
523 \item 
524
525 The constructor @Just@ returns by jumping to the second element of the
526 return vector with a pointer to the closure in \Arg{1}.  
527
528 \end{itemize}
529
530 In this way no test need be made to see which constructor returns;
531 instead, execution resumes immediately in the appropriate branch of
532 the @case@.
533
534 \subsection{Direct Returns}
535
536 When a datatype has a large number of constructors, it may be
537 inappropriate to use vectored returns.  The vector tables may be
538 large and sparse, and it may be better to identify the constructor
539 using a test-and-branch sequence on the tag.  For this reason, we
540 provide an alternative return convention, called a \emph{direct
541 return}.
542
543 In a direct return, the return address pushed on the stack really is a
544 code pointer.  The returning code loads a pointer to the closure being
545 returned in \Arg{1} as usual, and also loads the tag into \Arg{2}.
546 The code at the return address will test the tag and jump to the
547 appropriate code for the case branch.
548
549 The choice of whether to use a vectored return or a direct return is
550 made on a type-by-type basis --- up to a certain maximum number of
551 constructors imposed by the update mechanism
552 (section~\ref{sect:data-updates}).
553
554 Single-constructor data types also use direct returns, although in
555 that case there is no need to return a tag in \Arg{2}.
556
557 \ToDo{Say whether we pop the return address before returning}
558
559 \ToDo{Stack stubbing?}
560
561 \subsection{Updates}
562 \label{sect:data-updates}
563
564 The entry code for an updatable thunk (which must be of arity 0):
565
566 \begin{itemize}
567 \item copies the free variables out of the thunk into registers or
568   onto the stack.
569 \item pushes an {\em update frame} onto the stack.
570
571 An update frame is a small activation record consisting of
572 \begin{center}
573 \begin{tabular}{|l|l|l|}
574 \hline
575 {\em Fixed header} & {\em Update Frame link} & {\em Updatee} \\
576 \hline
577 \end{tabular}
578 \end{center}
579
580 \note{In the semantics part of the STG paper (section 5.6), an update
581 frame consists of everything down to the last update frame on the
582 stack.  This would make sense too --- and would fit in nicely with
583 what we're going to do when we add support for speculative
584 evaluation.}
585 \ToDo{I think update frames contain cost centres sometimes}
586
587 \item 
588 If we are doing ``eager blackholing,'' we then overwrite the thunk
589 with a black hole.  Otherwise, we leave it to the garbage collector to
590 black hole the thunk.
591
592 \item 
593 Start evaluating the body of the expression.
594
595 \end{itemize}
596
597 When the expression finishes evaluation, it will enter the update
598 frame on the top of the stack.  Since the returner doesn't know
599 whether it is entering a normal return address/vector or an update
600 frame, we follow exactly the same conventions as return addresses and
601 return vectors.  That is, on entering the update frame:
602
603 \begin{itemize} 
604 \item The value of the thunk is in \Arg{1}.  (Recall that only thunks
605 are updateable and that thunks return just one value.)
606
607 \item If the data type is a direct-return type rather than a
608 vectored-return type, then the tag is in \Arg{2}.
609
610 \item The update frame is still on the stack.
611 \end{itemize}
612
613 We can safely share a single statically-compiled update function
614 between all types.  However, the code must be able to handle both
615 vectored and direct-return datatypes.  This is done by arranging that
616 the update code looks like this:
617
618 @
619                 |       ^       |
620                 | return vector |
621                 |---------------|
622                 |  fixed-size   |
623                 |  info table   |
624                 |---------------|  <- update code pointer
625                 |  update code  |
626                 |       v       |
627 @
628
629 Each entry in the return vector (which is large enough to cover the
630 largest vectored-return type) points to the update code.
631
632 The update code:
633 \begin{itemize}
634 \item overwrites the {\em updatee} with an indirection to \Arg{1};
635 \item loads @Su@ from the Update Frame link;
636 \item removes the update frame from the stack; and 
637 \item enters \Arg{1}.
638 \end{itemize}
639
640 We enter \Arg{1} again, having probably just come from there, because
641 it knows whether to perform a direct or vectored return.  This could
642 be optimised by compiling special update code for each slot in the
643 return vector, which performs the correct return.
644
645 \subsection{Semi-tagging}
646 \label{sect:semi-tagging}
647
648 When a @case@ expression evaluates a variable that might be bound
649 to a thunk it is often the case that the scrutinee is already evaluated.
650 In this case we have paid the penalty of (a) pushing the return address (or
651 return vector address) on the stack, (b) jumping through the info pointer
652 of the scrutinee, and (c) returning by an indirect jump through the
653 return address on the stack.
654
655 If we knew that the scrutinee was already evaluated we could generate
656 (better) code which simply jumps to the appropriate branch of the
657 @case@ with a pointer to the scrutinee in \Arg{1}.  (For direct
658 returns to multiconstructor datatypes, we might also load the tag into
659 \Arg{2}).
660
661 An obvious idea, therefore, is to test dynamically whether the heap
662 closure is a value (using the tag in the info table).  If not, we
663 enter the closure as usual; if so, we jump straight to the appropriate
664 alternative.  Here, for example, is pseudo-code for the expression
665 @(case x of { (a,_,c) -> E }@:
666 @
667       \Arg{1} = <pointer to x>;
668       tag = \Arg{1}->entry->tag;
669       if (isWHNF(tag)) {
670           Sp--;  \\ insert space for return address
671           goto ret;
672       }
673       push(ret);           
674       goto \Arg{1}->entry;
675       
676       <info table for return address goes here>
677 ret:  a = \Arg{1}->data1; \\ suck out a and c to avoid space leak
678       c = \Arg{1}->data3;
679       <code for E2>
680 @
681 and here is the code for the expression @(case x of { [] -> E1; x:xs -> E2 }@:
682 @
683       \Arg{1} = <pointer to x>;
684       tag = \Arg{1}->entry->tag;
685       if (isWHNF(tag)) {
686           Sp--;  \\ insert space for return address
687           goto retvec[tag];
688       }
689       push(retinfo);          
690       goto \Arg{1}->entry;
691       
692       .addr ret2
693       .addr ret1
694 retvec:           \\ reversed return vector
695       <return info table for case goes here>
696 retinfo:
697       panic("Direct return into vectored case");
698       
699 ret1: <code for E1>
700
701 ret2: x  = \Arg{1}->head;
702       xs = \Arg{1}->tail;
703       <code for E2>
704 @
705 There is an obvious cost in compiled code size (but none in the size
706 of the bytecodes).  There is also a cost in execution time if we enter
707 more thunks than data constructors.
708
709 Both the direct and vectored returns are easily modified to chase chains
710 of indirections too.  In the vectored case, this is most easily done by
711 making sure that @IND = TAG_1 - 1@, and adding an extra field to every
712 return vector.  In the above example, the indirection code would be
713 @
714 ind:  \Arg{1} = \Arg{1}->next;
715       goto ind_loop;
716 @
717 where @ind_loop@ is the second line of code.
718
719 Note that we have to leave space for a return address since the return
720 address expects to find one.  If the body of the expression requires a
721 heap check, we will actually have to write the return address before
722 entering the garbage collector.
723
724
725 \subsection{Heap and Stack Checks}
726
727 \note{I reckon these deserve a subsection of their own}
728
729 The storage manager detects that it needs to garbage collect the old
730 generation when the evaluator requests a garbage collection without
731 having moved the heap pointer since the last garbage collection.  It
732 is therefore important that the GC routines {\em not} move the heap
733 pointer unless the heap check fails.  This is different from what
734 happens in the current STG implementation.
735
736 Talk about how stack check looks ahead into the branches of case expressions.
737
738
739 \subsection{Handling interrupts/signals}
740
741 @
742 May have to keep C stack pointer in register to placate OS?
743 May have to revert black holes - ouch!
744 @
745
746 \section{Interpreted Execution}
747
748 This section describes how the Hugs interpreter interprets code in the
749 same environment as compiled code executes.  Both evaluation models
750 use a common garbage collector, so they must agree on the form of
751 objects in the heap.
752
753 Hugs interprets code by converting it to byte-code and applying a
754 byte-code interpreter to it.  Wherever possible, we try to ensure that
755 the byte-code is all that is required to interpret a section of code.
756 This means not dynamically generating info tables, and hence we can
757 only have a small number of possible heap objects each with a staticly
758 compiled info table.  Similarly for stack objects: in fact we only
759 have one Hugs stack object, in which all information is tagged for the
760 garbage collector.
761
762 There is, however, one exception to this rule.  Hugs must generate
763 info tables for any constructors it is asked to compile, since the
764 alternative is to force a context-switch each time compiled code
765 enters a Hugs-built constructor, which would be prohibitively
766 expensive.
767
768 \subsection{Hugs Heap Objects}
769 \label{sect:hugs-heap-objects}
770
771 \subsubsection{Byte-Code Objects}
772
773 Compiled byte code lives on the global heap, in objects called
774 Byte-Code Objects (or BCOs).  The layout of BCOs is described in
775 detail in Section \ref{sect:BCO}, in this section we will describe
776 their semantics.
777
778 Since byte-code lives on the heap, it can be garbage collected just
779 like any other heap-resident data.  Hugs maintains a table of
780 currently live BCOs, which is treated as a table of live pointers by
781 the garbage collector.  When a module is unloaded, the pointers to its
782 BCOs are removed from the table, and the code will be garbage
783 collected some time later.
784
785 A BCO represents a basic block of code - all entry points are at the
786 beginning of a BCO, and it is impossible to jump into the middle of
787 one.  A BCO represents not only the code for a function, but also its
788 closure; a BCO can be entered just like any other closure.  Hugs
789 performs lambda-lifting during compilation to byte-code, and each
790 top-level combinator becomes a BCO in the heap.
791
792 \subsubsection{Thunks and partial applications}
793
794 A thunk consists of a code pointer, and values for the free variables
795 of that code.  Since Hugs byte-code is lambda-lifted, free variables
796 become arguments and are expected to be on the stack by the called
797 function.
798
799 Hugs represents thunks with an @HUGS_AP@ object.  The @HUGS_AP@ object
800 contains one or more pointers to other heap objects.  When it is
801 entered, it pushes an update frame followed by its payload on the
802 stack, and enters the first word (which will be a pointer to a BCO).
803 The layout of @HUGS_AP@ objects is described in more detail in Section
804 \ref{sect:HUGS-AP}.
805
806 Partial applications are represented by @HUGS_PAP@ objects, which are
807 identical to @HUGS_AP@s except that they are non-updatable.
808
809 \ToDo{Hugs Constructors}.
810
811 \subsection{Calling conventions}
812 \label{sect:hugs-calling-conventions}
813
814 The calling convention for any byte-code function is straightforward:
815
816 \begin{itemize}
817 \item Push any arguments on the stack.
818 \item Push a pointer to the BCO.
819 \item Begin interpreting the byte code.
820 \end{itemize}
821
822 The @ENTER@ byte-code instruction decides how to enter its argument.
823 The object being entered must be either
824
825 \begin{itemize}
826 \item A BCO,
827 \item A @HUGS_AP@,
828 \item A @HUGS_PAP@,
829 \item A constructor,
830 \item A GHC-built closure, or
831 \item An indirection.
832 \end{itemize}
833
834 If @ENTER@ is applied to a BCO, we just begin interpreting the
835 byte-code contained therein.  If the object is an @HUGS_AP@, we push an
836 update frame, push the values from the @HUGS_AP@ on the stack, and enter
837 its associated object.  If the object is a @HUGS_PAP@, we push its
838 values on the stack and enter the first one.  If the object is a
839 constructor, we simply return (see Section
840 \ref{sect:hugs-return-convention}).  The fourth case is convered in
841 Section \ref{sect:hugs-to-ghc-closure}.  If the object is an
842 indirection, we simply enter the object it points to.
843
844 \subsection{Return convention}
845 \label{sect:hugs-return-convention}
846
847 When Hugs pushes a return address, it pushes both a pointer to the BCO
848 to return to, and a pointer to a static code fragment @HUGS_RET@ (this
849 will be described in Section \ref{sect:ghc-to-hugs-return}).  The
850 stack layout is shown in Figure \ref{fig:hugs-return-stack}.
851
852 \begin{figure}
853 \begin{center}
854 \input{hugs_ret.pstex_t}
855 \end{center}
856 \caption{Stack layout for a Hugs return address}
857 \label{fig:hugs-return-stack}
858 \end{figure}
859
860 \begin{figure}
861 \begin{center}
862 \input{hugs_ret2.pstex_t}
863 \end{center}
864 \caption{Stack layout on enterings a Hugs return address}
865 \label{fig:hugs-return2}
866 \end{figure}
867
868 When a Hugs byte-code sequence is returning, it first places the
869 return value on the stack.  It then examines the return address (now
870 the second word on the stack):
871
872 \begin{itemize}
873
874 \item If the return address is @HUGS_RET@, rearrange the stack so that
875 it has the returned object followed by the pointer to the BCO at the
876 top, then enter the BCO (Figure \ref{fig:hugs-return2}).
877
878 \item If the top of the stack is not @HUGS_RET@, we need to do a world
879 switch as described in Section \ref{sect:hugs-to-ghc-return}.
880
881 \end{itemize}
882
883
884 \section{The Scheduler}
885
886 The Scheduler is the heart of the run-time system.  A running program
887 consists of a single running thread, and a list of runnable and
888 blocked threads.  The running thread returns to the scheduler when any
889 of the following conditions arises:
890
891 \begin{itemize}
892 \item A heap check fails, and a garbage collection is required
893 \item Compiled code needs to switch to interpreted code, and vice
894 versa.
895 \item The thread becomes blocked.
896 \item The thread is preempted.
897 \end{itemize}
898
899 A running system has a global state, consisting of
900
901 \begin{itemize}
902 \item @Hp@, the current heap pointer, which points to the next
903 available address in the Heap.
904 \item @HpLim@, the heap limit pointer, which points to the end of the
905 heap.
906 \item The Thread Preemption Flag, which is set whenever the currently
907 running thread should be preempted at the next opportunity.
908 \item A list of runnable threads. 
909 \item A list of blocked threads.
910 \end{itemize}
911
912 Each thread is represented by a Thread State Object (TSO), which is
913 described in detail in Section \ref{sect:TSO}.
914
915 The following is pseudo-code for the inner loop of the scheduler
916 itself.
917
918 @
919 while (threads_exist) {
920   // handle global problems: GC, parallelism, etc
921   if (need_gc) gc();  
922   if (external_message) service_message();
923   // deal with other urgent stuff
924
925   pick a runnable thread;
926   do {
927     switch (thread->whatNext) {
928       case (EnterGHC  pc): status=runGHC(pc);  break;
929       case (EnterHugs bc): status=runHugs(bc); break;
930     }
931     switch (status) {  // handle local problems
932       case (StackOverflow): enlargeStack; break;
933       case (Error e)      : error(thread,e); break;
934       case (ExitWith e)   : exit(e); break;
935       case (Yield)        : break;
936     }
937   } while (thread_runnable);
938 }
939 @
940
941 Optimisations to avoid excess trampolining from Hugs into itself.
942 How do we invoke GC, ccalls, etc.
943 General ccall (@ccall-GC@) and optimised ccall.
944
945 \section{Switching Worlds}
946
947 \label{sect:switching-worlds}
948
949 Because this is a combined compiled/interpreted system, the
950 interpreter will sometimes encounter compiled code, and vice-versa.
951
952 All world-switches go via the scheduler, ensuring that the world is in
953 a known state ready to enter either compiled code or the interpreter.
954 When a thread is run from the scheduler, the @whatNext@ field in the
955 TSO (Section \ref{sect:TSO}) is checked to find out how to execute the
956 thread.
957
958 \begin{itemize}
959 \item If @whatNext@ is set to @ReturnGHC@, we load up the required
960 registers from the TSO and jump to the address at the top of the user
961 stack.
962 \item If @whatNext@ is set to @EnterGHC@, we load up the required
963 registers from the TSO and enter the closure pointed to by the top
964 word of the stack.
965 \item If @whatNext@ is set to @EnterHugs@, we enter the top thing on
966 the stack, using the interpreter.
967 \end{itemize}
968
969 There are four cases we need to consider:
970
971 \begin{enumerate}
972 \item A GHC thread enters a Hugs-built closure.
973 \item A GHC thread returns to a Hugs-compiled return address.
974 \item A Hugs thread enters a GHC-built closure.
975 \item A Hugs thread returns to a Hugs-compiled return address.
976 \end{enumerate}
977
978 GHC-compiled modules cannot call functions in a Hugs-compiled module
979 directly, because the compiler has no information about arities in the
980 external module.  Therefore it must assume any top-level objects are
981 CAFs, and enter their closures.
982
983 \ToDo{dynamic linking stuff}
984 \ToDo{Hugs-built constructors?}
985
986 We now examine the various cases one by one and describe how the
987 switch happens in each situation.
988
989 \subsection{A GHC thread enters a Hugs-built closure}
990 \label{sect:ghc-to-hugs-closure}
991
992 There are three possibilities: GHC has entered the BCO directly (for a
993 top-level function closure), it has entered a @HUGS_AP@, or it has
994 entered a @HUGS_PAP@.
995
996 The code for all three objects is the same:
997
998 \begin{itemize}
999 \item Push the address of the object entered on the stack.
1000 \item Save the current state of the thread in its TSO.
1001 \item Return to the scheduler, setting @whatNext@ to @EnterHugs@.
1002 \end{itemize}
1003
1004 \subsection{A GHC thread returns to a Hugs-compiled return address}
1005 \label{sect:ghc-to-hugs-return}
1006
1007 Hugs return addresses are laid out as in Figure
1008 \ref{fig:hugs-return-stack}.  If GHC is returning, it will return to
1009 the address at the top of the stack, namely @HUGS_RET@.  The code at
1010 @HUGS_RET@ performs the following:
1011
1012 \begin{itemize}
1013 \item pushes \Arg{1} (the return value) on the stack.
1014 \item saves the thread state in the TSO
1015 \item returns to the scheduler with @whatNext@ set to @EnterHugs@.
1016 \end{itemize}
1017
1018 \noindent When Hugs runs, it will enter the return value, which will
1019 return using the correct Hugs convention (Section
1020 \ref{sect:hugs-return-convention}) to the return address underneath it
1021 on the stack.
1022
1023 \subsection{A Hugs thread enters a GHC-compiled closure}
1024 \label{sect:hugs-to-ghc-closure}
1025
1026 Hugs can recognise a GHC-built closure as not being one of the
1027 following types of object:
1028
1029 \begin{itemize}
1030 \item A @BCO@,
1031 \item A @HUGS_AP@,
1032 \item A @HUGS_PAP@,
1033 \item An indirection, or
1034 \item A constructor.
1035 \end{itemize}
1036
1037 When Hugs is called on to enter a GHC closure, it executes the
1038 following sequence of instructions:
1039
1040 \begin{itemize}
1041 \item Push the address of the closure on the stack.
1042 \item Save the current state of the thread in the TSO.
1043 \item Return to the scheduler, with the @whatNext@ field set to
1044 @EnterGHC@.
1045 \end{itemize}
1046
1047 \subsection{A Hugs thread returns to a GHC-compiled return address}
1048 \label{sect:hugs-to-ghc-return}
1049
1050 When hugs encounters a return address on the stack that is not
1051 @HUGS_RET@, it knows that a world-switch is required.  At this point
1052 the stack contains a pointer to the return value, followed by the GHC
1053 return address.  The following sequence is then performed:
1054
1055 \begin{itemize}
1056 \item save the state of the thread in the TSO.
1057 \item return to the scheduler, setting @whatNext@ to @EnterGHC@.
1058 \end{itemize}
1059
1060 The first thing that GHC will do is enter the object on the top of the
1061 stack, which is a pointer to the return value.  This value will then
1062 return itself to the return address using the GHC return convention.
1063
1064 \part{Implementation}
1065 \section{Heap objects}
1066 \label{sect:fixed-header}
1067
1068 \ToDo{Fix this picture}
1069
1070 \begin{figure}
1071 \begin{center}
1072 \input{closure}
1073 \end{center}
1074 \caption{A closure}
1075 \label{fig:closure}
1076 \end{figure}
1077
1078 Every {\em heap object} is a contiguous block
1079 of memory, consisting of a fixed-format {\em header} followed
1080 by zero or more {\em data words}.
1081
1082 \ToDo{I absolutely do not believe that every heap object has a header
1083 like this - ADR.  I believe that they all have an info pointer but I
1084 see no readon why stack objects and unpointed heap objects would have
1085 an entry count since this will always be zero.}
1086
1087 The header consists of the following fields:
1088 \begin{itemize}
1089 \item A one-word {\em info pointer}, which points to
1090 the object's static {\em info table}.
1091 \item Zero or more {\em admin words} that support
1092 \begin{itemize}
1093 \item Profiling (notably a {\em cost centre} word).
1094   \note{We could possibly omit the cost centre word from some 
1095   administrative objects.}
1096 \item Parallelism (e.g. GranSim keeps the object's global address here,
1097 though GUM keeps a separate hash table).
1098 \item Statistics (e.g. a word to track how many times a thunk is entered.).
1099
1100 We add a Ticky word to the fixed-header part of closures.  This is
1101 used to indicate if a closure has been updated but not yet entered. It
1102 is set when the closure is updated and cleared when subsequently
1103 entered.
1104
1105 NB: It is {\em not} an ``entry count'', it is an
1106 ``entries-after-update count.''  The commoning up of @CONST@,
1107 @CHARLIKE@ and @INTLIKE@ closures is turned off(?) if this is
1108 required. This has only been done for 2s collection.
1109
1110 \end{itemize}
1111 \end{itemize}
1112
1113 Most of the RTS is completely insensitive to the number of admin words.
1114 The total size of the fixed header is @FIXED_HS@.
1115
1116 Many heap objects contain fields allowing them to be inserted onto lists
1117 during evaluation or during garbage collection. The lists required by
1118 the evaluator and storage manager are as follows.
1119
1120 \begin{itemize}
1121 \item 2 lists of threads: runnable threads and sleeping threads.
1122
1123 \item The {\em static object list} is a list of all statically
1124 allocated objects which might contain pointers into the heap.
1125 (Section~\ref{sect:static-objects}.)
1126
1127 \item The {\em updated thunk list} is a list of all thunks in the old
1128 generation which have been updated with an indirection.  
1129 (Section~\ref{sect:IND_OLDGEN}.)
1130
1131 \item The {\em mutables list} is a list of all other objects in the
1132 old generation which might contain pointers into the new generation.
1133 Most of the object on this list are ``mutable.''
1134 (Section~\ref{sect:mutables}.)
1135
1136 \item The {\em Foreign Object list} is a list of all foreign objects
1137  which have not yet been deallocated. (Section~\ref{sect:FOREIGN}.)
1138
1139 \item The {\em Spark pool} is a doubly(?) linked list of Spark objects
1140 maintained by the parallel system.  (Section~\ref{sect:SPARK}.)
1141
1142 \item The {\em Blocked Fetch list} (or
1143 lists?). (Section~\ref{sect:BLOCKED_FETCH}.)
1144
1145 \item For each thread, there is a list of all update frames on the
1146 stack.  (Section~\ref{sect:data-updates}.)
1147
1148
1149 \end{itemize}
1150
1151 \ToDo{The links for these fields are usually inserted immediately
1152 after the fixed header except ...}
1153
1154 \subsection{Info Tables}
1155
1156 An {\em info table} is a contiguous block of memory, {\em laid out
1157 backwards}.  That is, the first field in the list that follows
1158 occupies the highest memory address, and the successive fields occupy
1159 successive decreasing memory addresses.
1160
1161 \begin{center}
1162 \begin{tabular}{|c|}
1163    \hline Parallelism Info 
1164 \\ \hline Profile Info 
1165 \\ \hline Debug Info 
1166 \\ \hline Tag / Static reference table
1167 \\ \hline Storage manager layout info
1168 \\ \hline Closure type 
1169 \\ \hline entry code
1170 \\       \vdots
1171 \end{tabular}
1172 \end{center}
1173 An info table has the following contents (working backwards in memory
1174 addresses):
1175 \begin{itemize}
1176 \item The {\em entry code} for the closure.
1177 This code appears literally as the (large) last entry in the
1178 info table, immediately preceded by the rest of the info table.
1179 An {\em info pointer} always points to the first byte of the entry code.
1180
1181 \item A one-word {\em closure type field}, @INFO_TYPE@, identifies what kind
1182 of closure the object is.  The various types of closure are described
1183 in Section~\ref{sect:closures}.
1184 In some configurations, some useful properties of 
1185 closures (is it a HNF?  can it be sparked?)
1186 are represented as high-order bits so they can be tested quickly.
1187
1188 \item A single pointer or word --- the {\em storage manager info field},
1189 @INFO_SM@, contains auxiliary information describing the closure's
1190 precise layout, for the benefit of the garbage collector and the code
1191 that stuffs graph into packets for transmission over the network.
1192
1193 \item A one-word {\em Tag/Static Reference Table} field, @INFO_SRT@.
1194 For data constructors, this field contains the constructor tag, in the
1195 range $0..n-1$ where $n$ is the number of constructors.  For all other
1196 objects it contains a pointer to a table which enables the garbage
1197 collector to identify all accessible code and CAFs.  They are fully
1198 described in Section~\ref{sect:srt}.
1199
1200 \item {\em Profiling info\/}
1201
1202 Closure category records are attached to the info table of the
1203 closure. They are declared with the info table. We put pointers to
1204 these ClCat things in info tables.  We need these ClCat things because
1205 they are mutable, whereas info tables are immutable.  Hashing will map
1206 similar categories to the same hash value allowing statistics to be
1207 grouped by closure category.
1208
1209 Cost Centres and Closure Categories are hashed to provide indexes
1210 against which arbitrary information can be stored. These indexes are
1211 memoised in the appropriate cost centre or category record and
1212 subsequent hashes avoided by the index routine (it simply returns the
1213 memoised index).
1214
1215 There are different features which can be hashed allowing information
1216 to be stored for different groupings. Cost centres have the cost
1217 centre recorded (using the pointer), module and group. Closure
1218 categories have the closure description and the type
1219 description. Records with the same feature will be hashed to the same
1220 index value.
1221
1222 The initialisation routines, @init_index_<feature>@, allocate a hash
1223 table in which the cost centre / category records are stored. The
1224 lower bound for the table size is taken from @max_<feature>_no@. They
1225 return the actual table size used (the next power of 2). Unused
1226 locations in the hash table are indicated by a 0 entry. Successive
1227 @init_index_<feature>@ calls just return the actual table size.
1228
1229 Calls to @index_<feature>@ will insert the cost centre / category
1230 record in the @<feature>@ hash table, if not already inserted. The hash
1231 index is memoised in the record and returned. 
1232
1233 CURRENTLY ONLY ONE MEMOISATION SLOT IS AVILABLE IN EACH RECORD SO
1234 HASHING CAN ONLY BE DONE ON ONE FEATURE FOR EACH RECORD. This can be
1235 easily relaxed at the expense of extra memoisation space or continued
1236 rehashing.
1237
1238 The initialisation routines must be called before initialisation of
1239 the stacks and heap as they require to allocate storage. It is also
1240 expected that the caller may want to allocate additional storage in
1241 which to store profiling information based on the return table size
1242 value(s).
1243
1244 \begin{center}
1245 \begin{tabular}{|l|}
1246    \hline Hash Index
1247 \\ \hline Selected
1248 \\ \hline Kind
1249 \\ \hline Description String
1250 \\ \hline Type String
1251 \\ \hline
1252 \end{tabular}
1253 \end{center}
1254
1255 \begin{description}
1256 \item[Hash Index] Memoised copy
1257 \item[Selected] 
1258   Is this category selected (-1 == not memoised, selected? 0 or 1)
1259 \item[Kind]
1260 One of the following values (defined in CostCentre.lh):
1261
1262 \begin{description}
1263 \item[@CON_K@]
1264 A constructor.
1265 \item[@FN_K@]
1266 A literal function.
1267 \item[@PAP_K@]
1268 A partial application.
1269 \item[@THK_K@]
1270 A thunk, or suspension.
1271 \item[@BH_K@]
1272 A black hole.
1273 \item[@ARR_K@]
1274 An array.
1275 \item[@ForeignObj_K@]
1276 A Foreign object (non-Haskell heap resident).
1277 \item[@SPT_K@]
1278 The Stable Pointer table.  (There should only be one of these but it
1279 represents a form of weak space leak since it can't shrink to meet
1280 non-demand so it may be worth watching separately? ADR)
1281 \item[@INTERNAL_KIND@]
1282 Something internal to the runtime system.
1283 \end{description}
1284
1285
1286 \item[Description] Source derived string detailing closure description.
1287 \item[Type] Source derived string detailing closure type.
1288 \end{description}
1289
1290 \item {\em Parallelism info\/}
1291 \ToDo{}
1292
1293 \item {\em Debugging info\/}
1294 \ToDo{}
1295
1296 \end{itemize}
1297
1298
1299 %-----------------------------------------------------------------------------
1300 \subsection{Kinds of Heap Object}
1301 \label{sect:closures}
1302
1303 Heap objects can be classified in several ways, but one useful one is
1304 this:
1305 \begin{itemize}
1306 \item 
1307 {\em Static closures} occupy fixed, statically-allocated memory
1308 locations, with globally known addresses.
1309
1310 \item 
1311 {\em Dynamic closures} are individually allocated in the heap.
1312
1313 \item 
1314 {\em Stack closures} are closures allocated within a thread's stack
1315 (which is itself a heap object).  Unlike other closures, there are
1316 never any pointers to stack closures.  Stack closures are discussed in
1317 Section~\ref{sect:stacks}.
1318
1319 \end{itemize}
1320 A second useful classification is this:
1321 \begin{itemize}
1322 \item 
1323 {\em Executive objects}, such as thunks and data constructors,
1324 participate directly in a program's execution.  They can be subdivided into
1325 three kinds of objects according to their type:
1326 \begin{itemize}
1327 \item 
1328 {\em Pointed objects}, represent values of a {\em pointed} type
1329 (<.pointed types launchbury.>) --i.e.~a type that includes $\bottom$ such as @Int@ or @Int# -> Int#@.
1330
1331 \item {\em Unpointed objects}, represent values of a {\em unpointed} type --i.e.~a type that does not include $\bottom$ such as @Int#@ or @Array#@.
1332
1333 \item {\em Activation frames}, represent ``continuations''.  They are
1334 always stored on the stack and are never pointed to by heap objects or
1335 passed as arguments.  \note{It's not clear if this will still be true
1336 once we support speculative evaluation.}
1337
1338 \end{itemize}
1339
1340 \item {\em Administrative objects}, such as stack objects and thread
1341 state objects, do not represent values in the original program.
1342 \end{itemize}
1343
1344 Only pointed objects can be entered.  All pointed objects share a
1345 common header format: the ``pointed header''; while all unpointed
1346 objects share a common header format: the ``unpointed header''.
1347 \ToDo{Describe the difference and update the diagrams to mention
1348 an appropriate header type.}
1349
1350 This section enumerates all the kinds of heap objects in the system.
1351 Each is identified by a distinct @INFO_TYPE@ tag in its info table.
1352
1353 \ToDo{Check this table very carefully}
1354
1355 \begin{tabular}{|l|l|l|l|l|l|l|l|l|l|l|}
1356 \hline
1357
1358 closure kind          & HNF & UPD & NS & STA & THU & MUT & UPT & BH & IND & Section \\
1359
1360 \hline                                                              
1361 {\em Pointed} \\ 
1362 \hline 
1363
1364 @CONSTR@              & 1 &   & 1 &   &   &   &   &   &   & \ref{sect:CONSTR}    \\
1365 @CONSTR_STATIC@       & 1 &   & 1 & 1 &   &   &   &   &   & \ref{sect:CONSTR}    \\
1366 @CONSTR_STATIC_NOCAF@ & 1 &   & 1 & 1 &   &   &   &   &   & \ref{sect:CONSTR}    \\
1367
1368 @FUN@                 & 1 &   & ? &   &   &   &   &   &   & \ref{sect:FUN}       \\
1369 @FUN_STATIC@          & 1 &   & ? & 1 &   &   &   &   &   & \ref{sect:FUN}       \\
1370
1371 @THUNK@               &   & 1 &   &   & 1 &   &   &   &   & \ref{sect:THUNK}     \\
1372 @THUNK_STATIC@        &   & 1 &   & 1 & 1 &   &   &   &   & \ref{sect:THUNK}     \\
1373 @THUNK_SELECTOR@      &   & 1 & 1 &   & 1 &   &   &   &   & \ref{sect:THUNK_SEL} \\
1374
1375 @BCO@                 & 1 &   & 1 &   &   &   &   &   &   & \ref{sect:BCO}       \\
1376 @BCO_CAF@             &   & 1 &   &   & 1 &   &   &   &   & \ref{sect:BCO}       \\
1377
1378 @HUGS_AP@             &   & 1 &   &   & 1 &   &   &   &   & \ref{sect:HUGS-AP}   \\
1379 @HUGS_PAP@            &   &   & 1 &   &   &   &   &   &   & \ref{sect:HUGS-AP}   \\
1380
1381 @PAP@                 & 1 &   & 1 &   &   &   &   &   &   & \ref{sect:PAP}       \\
1382
1383 @IND@                 & ? &   & ? &   & ? &   &   &   & 1 & \ref{sect:IND}       \\
1384 @IND_OLDGEN@          & ? &   & ? &   & ? &   &   &   & 1 & \ref{sect:IND}       \\
1385 @IND_PERM@            & ? &   & ? &   & ? &   &   &   & 1 & \ref{sect:IND}       \\
1386 @IND_OLDGEN_PERM@     & ? &   & ? &   & ? &   &   &   & 1 & \ref{sect:IND}       \\
1387 @IND_STATIC@          & ? &   & ? & 1 & ? &   &   &   & 1 & \ref{sect:IND}       \\
1388                                                          
1389 \hline                                                   
1390 {\em Unpointed} \\                                       
1391 \hline                                                   
1392                                                          
1393                                                          
1394 @ARR_WORDS@           & 1 &   & 1 &   &   &   & 1 &   &   & \ref{sect:ARR_WORDS1},\ref{sect:ARR_WORDS2} \\
1395 @ARR_PTRS@            & 1 &   & 1 &   &   &   & 1 &   &   & \ref{sect:ARR_PTRS}  \\
1396 @MUTVAR@              & 1 &   & 1 &   &   & 1 & 1 &   &   & \ref{sect:MUTVAR}    \\
1397 @MUTARR_PTRS@         & 1 &   & 1 &   &   & 1 & 1 &   &   & \ref{sect:MUTARR_PTRS} \\
1398 @MUTARR_PTRS_FROZEN@  & 1 &   & 1 &   &   & 1 & 1 &   &   & \ref{sect:MUTARR_PTRS_FROZEN} \\
1399                                                          
1400 @FOREIGN@             & 1 &   & 1 &   &   &   & 1 &   &   & \ref{sect:FOREIGN}   \\
1401                                                          
1402 @BH@                  &   & 1 & 1 &   & ? & ? &   & 1 & ? & \ref{sect:BH}        \\
1403 @MVAR@                & 1 &   & 1 &   &   &   &   &   &   & \ref{sect:MVAR}      \\
1404 @IVAR@                & 1 &   & 1 &   &   &   &   &   &   & \ref{sect:IVAR}      \\
1405 @FETCHME@             & 1 &   & 1 &   &   &   &   &   &   & \ref{sect:FETCHME}   \\
1406 \hline
1407 \end{tabular}
1408
1409 Activation frames do not live (directly) on the heap --- but they have
1410 a similar organisation.  The classification bits are all zero in
1411 activation frames.
1412
1413 \begin{tabular}{|l|l|}\hline
1414 closure kind            & Section                       \\ \hline
1415 @RET_SMALL@             & \ref{sect:activation-records} \\
1416 @RET_VEC_SMALL@         & \ref{sect:activation-records} \\
1417 @RET_BIG@               & \ref{sect:activation-records} \\
1418 @RET_VEC_BIG@           & \ref{sect:activation-records} \\
1419 @UPDATE_FRAME@          & \ref{sect:activation-records} \\
1420 \hline
1421 \end{tabular}
1422
1423 There are also a number of administrative objects.  The classification bits are
1424 all zero in administrative objects.
1425
1426 \begin{tabular}{|l|l|}\hline
1427 closure kind            & Section                       \\ \hline
1428 @TSO@                   & \ref{sect:TSO}                \\
1429 @STACK_OBJECT@          & \ref{sect:STACK_OBJECT}       \\
1430 @STABLEPTR_TABLE@       & \ref{sect:STABLEPTR_TABLE}    \\
1431 @SPARK_OBJECT@          & \ref{sect:SPARK}              \\
1432 @BLOCKED_FETCH@         & \ref{sect:BLOCKED_FETCH}      \\
1433 \hline
1434 \end{tabular}
1435
1436 \ToDo{I guess the parallel system has something like a stable ptr
1437 table.  Is there any opportunity for sharing code/data structures
1438 here?}
1439
1440
1441 \subsection{Classification bits}
1442
1443 The top bits of the @INFO_TYPE@ tag tells what sort of animal the
1444 closure is.
1445
1446 \begin{tabular}{|l|l|l|}                                                        \hline
1447 Abbrev & Bit & Interpretation                                                   \\ \hline
1448 HNF    & 0   & 1 $\Rightarrow$ Head normal form                                 \\
1449 UPD    & 4   & 1 $\Rightarrow$ May be updated (inconsistent with being a HNF)   \\ 
1450 NS     & 1   & 1 $\Rightarrow$ Don't spark me  (Any HNF will have this set to 1)\\
1451 STA    & 2   & 1 $\Rightarrow$ This is a static closure                         \\
1452 THU    & 8   & 1 $\Rightarrow$ Is a thunk                                       \\
1453 MUT    & 3   & 1 $\Rightarrow$ Has mutable pointer fields                       \\ 
1454 UPT    & 5   & 1 $\Rightarrow$ Has an unpointed type (eg a primitive array)     \\
1455 BH     & 6   & 1 $\Rightarrow$ Is a black hole                                  \\
1456 IND    & 7   & 1 $\Rightarrow$ Is an indirection                                \\
1457 \hline
1458 \end{tabular}
1459
1460 Updatable structures (@_UP@) are thunks that may be shared.  Primitive
1461 arrays (@_BM@ -- Big Mothers) are structures that are always held
1462 in-memory (basically extensions of a closure).  Because there may be
1463 offsets into these arrays, a primitive array cannot be handled as a
1464 FetchMe in the parallel system, but must be shipped in its entirety if
1465 its parent closure is shipped.
1466
1467 The other bits in the info-type field simply give a unique bit-pattern
1468 to identify the closure type.
1469
1470 \iffalse
1471 @
1472 #define _NF                     0x0001  /* Normal form  */
1473 #define _NS                     0x0002  /* Don't spark  */
1474 #define _ST                     0x0004  /* Is static    */
1475 #define _MU                     0x0008  /* Is mutable   */
1476 #define _UP                     0x0010  /* Is updatable (but not mutable) */
1477 #define _BM                     0x0020  /* Is a "primitive" array */
1478 #define _BH                     0x0040  /* Is a black hole */
1479 #define _IN                     0x0080  /* Is an indirection */
1480 #define _TH                     0x0100  /* Is a thunk */
1481
1482
1483
1484 SPEC    
1485 SPEC_N          SPEC | _NF | _NS
1486 SPEC_S          SPEC | _TH
1487 SPEC_U          SPEC | _UP | _TH
1488                 
1489 GEN     
1490 GEN_N           GEN | _NF | _NS
1491 GEN_S           GEN | _TH
1492 GEN_U           GEN | _UP | _TH
1493                 
1494 DYN             _NF | _NS
1495 TUPLE           _NF | _NS | _BM
1496 DATA            _NF | _NS | _BM
1497 MUTUPLE         _NF | _NS | _MU | _BM
1498 IMMUTUPLE       _NF | _NS | _BM
1499 STATIC          _NS | _ST
1500 CONST           _NF | _NS
1501 CHARLIKE        _NF | _NS
1502 INTLIKE         _NF | _NS
1503
1504 BH              _NS | _BH
1505 BH_N            BH
1506 BH_U            BH | _UP
1507                 
1508 BQ              _NS | _MU | _BH
1509 IND             _NS | _IN
1510 CAF             _NF | _NS | _ST | _IN
1511
1512 FM              
1513 FETCHME         FM | _MU
1514 FMBQ            FM | _MU | _BH
1515
1516 TSO             _MU
1517
1518 STKO    
1519 STKO_DYNAMIC    STKO | _MU
1520 STKO_STATIC     STKO | _ST
1521                 
1522 SPEC_RBH        _NS | _MU | _BH
1523 GEN_RBH         _NS | _MU | _BH
1524 BF              _NS | _MU | _BH
1525 INTERNAL        
1526
1527 @
1528 \fi
1529
1530 Notes:
1531
1532 An indirection either points to HNF (post update); or is result of
1533 overwriting a FetchMe, in which case the thing fetched is either
1534 under evaluation (BH), or by now an HNF.  Thus, indirections get NoSpark flag.
1535
1536
1537
1538 \subsection{Hugs Objects}
1539
1540 \subsubsection{Byte-Code Objects}
1541 \label{sect:BCO}
1542
1543 A Byte-Code Object (BCO) is a container for a a chunk of byte-code,
1544 which can be executed by Hugs.  The byte-code represents a
1545 supercombinator in the program: when hugs compiles a module, it
1546 performs lambda lifting and each resulting supercombinator becomes a
1547 byte-code object in the heap.
1548
1549 There are two kinds of BCO: a standard @BCO@ which has an arity of one
1550 or more, and a @BCO_CAF@ which takes no arguments and can be updated.
1551 When a @BCO_CAF@ is updated, the code is thrown away!
1552
1553 The semantics of BCOs are described in Section
1554 \ref{sect:hugs-heap-objects}.  A BCO has the following structure:
1555
1556 \begin{center}
1557 \begin{tabular}{|l|l|l|l|l|l|}
1558 \hline 
1559 \emph{Fixed Header} & \emph{Layout} & \emph{Offset} & \emph{Size} &
1560 \emph{Literals} & \emph{Byte code} \\
1561 \hline
1562 \end{tabular}
1563 \end{center}
1564
1565 \noindent where:
1566 \begin{itemize}
1567 \item The entry code is a static code fragment/info table that
1568 returns to the scheduler to invoke Hugs (Section
1569 \ref{sect:ghc-to-hugs-closure}).
1570 \item \emph{Layout} contains the number of pointer literals in the
1571 \emph{Literals} field.
1572 \item \emph{Offset} is the offset to the byte code from the start of
1573 the object.
1574 \item \emph{Size} is the number of words of byte code in the object.
1575 \item \emph{Literals} contains any pointer and non-pointer literals used in
1576 the byte-codes (including jump addresses), pointers first.
1577 \item \emph{Byte code} contains \emph{Size} words of non-pointer byte
1578 code.
1579 \end{itemize}
1580
1581 \subsubsection{@HUGS_AP@ objects}
1582 \label{sect:HUGS-AP}
1583
1584 There are two kinds of @HUGS_AP@ objects: a standard @HUGS_AP@, used
1585 to represent thunks buit by Hugs, and a @HUGS_PAP@, used for partial
1586 applications.  The only difference between the two is that a
1587 @HUGS_PAP@ is non-updatable.
1588
1589 \begin{center}
1590 \begin{tabular}{|l|l|l|l|}
1591 \hline
1592 \emph{Fixed Header} & \emph{BCO} & \emph{Layout} & \emph{Free Variables} \\
1593 \hline
1594 \end{tabular}
1595 \end{center}
1596
1597 \noindent where:
1598
1599 \begin{itemize}
1600
1601 \item The entry code is a statically-compiled code fragment/info table
1602 that returns to the scheduler to invoke Hugs (Sections
1603 \ref{sect:ghc-to-hugs-closure}, \ref{sect:ghc-to-hugs-return}).
1604
1605 \item \emph{BCO} is a pointer to the BCO for the thunk.
1606
1607 \item \emph{Layout} contains the number of pointers and the size of
1608 the \emph{Free Variables} field.
1609
1610 \item \emph{Free Variables} contains the free variables of the
1611 thunk/partial application/return address, pointers first.
1612
1613 \end{itemize}
1614
1615 \subsection{Pointed Objects}
1616
1617 All pointed objects can be entered.
1618
1619 \subsubsection{Function closures}\label{sect:FUN}
1620
1621 Function closures represent lambda abstractions.  For example,
1622 consider the top-level declaration:
1623 @
1624   f = \x -> let g = \y -> x+y
1625             in g x
1626 @
1627 Both @f@ and @g@ are represented by function closures.  The closure
1628 for @f@ is {\em static} while that for @g@ is {\em dynamic}.
1629
1630 The layout of a function closure is as follows:
1631 \begin{center}
1632 \begin{tabular}{|l|l|l|l|}\hline
1633 {\em Fixed header}  & {\em Pointers} & {\em Non-pointers} \\ \hline
1634 \end{tabular}
1635 \end{center}
1636 The data words (pointers and non-pointers) are the free variables of
1637 the function closure.  
1638 The number of pointers
1639 and number of non-pointers are stored in the @INFO_SM@ word, in the least significant
1640 and most significant half-word respectively.
1641
1642 There are several different sorts of function closure, distinguished
1643 by their @INFO_TYPE@ field:
1644 \begin{itemize}
1645 \item @FUN@: a vanilla, dynamically allocated on the heap. 
1646
1647 \item $@FUN_@p@_@np$: to speed up garbage collection a number of
1648 specialised forms of @FUN@ are provided, for particular $(p,np)$ pairs,
1649 where $p$ is the number of pointers and $np$ the number of non-pointers.
1650
1651 \item @FUN_STATIC@.  Top-level, static, function closures (such as
1652 @f@ above) have a different
1653 layout than dynamic ones:
1654 \begin{center}
1655 \begin{tabular}{|l|l|l|}\hline
1656 {\em Fixed header}  & {\em Static object link} \\ \hline
1657 \end{tabular}
1658 \end{center}
1659 Static function closures have no free variables.  (However they may refer to other 
1660 static closures; these references are recorded in the function closure's SRT.)
1661 They have one field that is not present in dynamic closures, the {\em static object
1662 link} field.  This is used by the garbage collector in the same way that to-space
1663 is, to gather closures that have been determined to be live but that have not yet
1664 been scavenged.
1665 \note{Static function closures that have no static references, and hence
1666 a null SRT pointer, don't need the static object link field.  Is it worth
1667 taking advantage of this?  See @CONSTR_STATIC_NOCAF@.}
1668 \end{itemize}
1669
1670 Each lambda abstraction, $f$, in the STG program has its own private info table.
1671 The following labels are relevant:
1672 \begin{itemize}
1673 \item $f$@_info@  is $f$'s info table.
1674 \item $f$@_entry@ is $f$'s slow entry point (i.e. the entry code of its
1675 info table; so it will label the same byte as $f$@_info@).
1676 \item $f@_fast_@k$ is $f$'s fast entry point.  $k$ is the number of arguments
1677 $f$ takes; encoding this number in the fast-entry label occasionally catches some nasty
1678 code-generation errors.
1679 \end{itemize}
1680
1681 \subsubsection{Data Constructors}\label{sect:CONSTR}
1682
1683 Data-constructor closures represent values constructed with
1684 algebraic data type constructors.
1685 The general layout of data constructors is the same as that for function
1686 closures.  That is
1687 \begin{center}
1688 \begin{tabular}{|l|l|l|l|}\hline
1689 {\em Fixed header}  & {\em Pointers} & {\em Non-pointers} \\ \hline
1690 \end{tabular}
1691 \end{center}
1692
1693 The SRT pointer in a data constructor's info table is used for the
1694 constructor tag, since a constructor never has any static references.
1695
1696 There are several different sorts of constructor:
1697 \begin{itemize}
1698 \item @CONSTR@: a vanilla, dynamically allocated constructor.
1699 \item @CONSTR_@$p$@_@$np$: just like $@FUN_@p@_@np$.
1700 \item @CONSTR_INTLIKE@.
1701 A dynamically-allocated heap object that looks just like an @Int@.  The 
1702 garbage collector checks to see if it can common it up with one of a fixed
1703 set of static int-like closures, thus getting it out of the dynamic heap
1704 altogether.
1705
1706 \item @CONSTR_CHARLIKE@:  same deal, but for @Char@.
1707
1708 \item @CONSTR_STATIC@ is similar to @FUN_STATIC@, with the complication that
1709 the layout of the constructor must mimic that of a dynamic constructor,
1710 because a static constructor might be returned to some code that unpacks it.
1711 So its layout is like this:
1712 \begin{center}
1713 \begin{tabular}{|l|l|l|l|l|}\hline
1714 {\em Fixed header}  & {\em Pointers} & {\em Non-pointers} & {\em Static object link}\\ \hline
1715 \end{tabular}
1716 \end{center}
1717 The static object link, at the end of the closure, serves the same purpose
1718 as that for @FUN_STATIC@.  The pointers in the static constructor can point
1719 only to other static closures.
1720
1721 The static object link occurs last in the closure so that static
1722 constructors can store their data fields in exactly the same place as
1723 dynamic constructors.
1724
1725 \item @CONSTR_STATIC_NOCAF@.  A statically allocated data constructor
1726 that guarantees not to point (directly or indirectly) to any CAF
1727 (section~\ref{sect:CAF}).  This means it does not need a static object
1728 link field.  Since we expect that there might be quite a lot of static
1729 constructors this optimisation makes sense.  Furthermore, the @NOCAF@
1730 tag allows the compiler to indicate that no CAFs can be reached
1731 anywhere {\em even indirectly}.
1732
1733
1734 \end{itemize}
1735
1736 For each data constructor $Con$, two
1737 info tables are generated:
1738 \begin{itemize}
1739 \item $Con$@_info@ labels $Con$'s dynamic info table, 
1740 shared by all dynamic instances of the constructor.
1741 \item $Con$@_static@ labels $Con$'s static info table, 
1742 shared by all static instances of the constructor.
1743 \end{itemize}
1744
1745 \subsubsection{Thunks}
1746 \label{sect:THUNK}
1747 \label{sect:THUNK_SEL}
1748
1749 A thunk represents an expression that is not obviously in head normal 
1750 form.  For example, consider the following top-level definitions:
1751 @
1752   range = between 1 10
1753   f = \x -> let ys = take x range
1754             in sum ys
1755 @
1756 Here the right-hand sides of @range@ and @ys@ are both thunks; the former
1757 is static while the latter is dynamic.
1758
1759 The layout of a thunk is the same as that for a function closure,
1760 except that it may have some words of ``slop'' at the end to make sure
1761 that it has 
1762 at least @MIN_UPD_PAYLOAD@ words in addition to its
1763 fixed header.
1764 \begin{center}
1765 \begin{tabular}{|l|l|l|l|l|}\hline
1766 {\em Fixed header}  & {\em Pointers} & {\em Non-pointers} & {\em Slop} \\ \hline
1767 \end{tabular}
1768 \end{center}
1769 The @INFO_SM@ word contains the same information as for function
1770 closures; that is, number of pointers and number of non-pointers (excluding slop).
1771
1772 A thunk differs from a function closure in that it can be updated.
1773
1774 There are several forms of thunk:
1775 \begin{itemize}
1776 \item @THUNK@: a vanilla, dynamically allocated thunk.
1777 The garbage collection code for thunks whose
1778 pointer + non-pointer words is less than @MIN_UPD_PAYLOAD@ differs from
1779 that for function closures and data constructors, because the GC code
1780 has to account for the slop.
1781 \item $@THUNK_@p@_@np$.  Similar comments apply.
1782 \item @THUNK_STATIC@.  A static thunk is also known as 
1783 a {\em constant applicative form}, or {\em CAF}.
1784
1785 \begin{center}
1786 \begin{tabular}{|l|l|l|l|l|}\hline
1787 {\em Fixed header}  & {\em Pointers} & {\em Non-pointers} & {\em Slop} & {\em Static object link}\\ \hline
1788 \end{tabular}
1789 \end{center}
1790
1791 \item @THUNK_SELECTOR@ is a (dynamically allocated) thunk
1792 whose entry code performs a simple selection operation from
1793 a data constructor drawn from a single-constructor type.  For example,
1794 the thunk
1795 @
1796         x = case y of (a,b) -> a
1797 @
1798 is a selector thunk.  A selector thunk is laid out like this:
1799 \begin{center}
1800 \begin{tabular}{|l|l|l|l|}\hline
1801 {\em Fixed header}  & {\em Selectee pointer} \\ \hline
1802 \end{tabular}
1803 \end{center}
1804 The @INFO_SM@ word contains the byte offset of the desired word in
1805 the selectee.  Note that this is different from all other thunks.
1806
1807 The garbage collector ``peeks'' at the selectee's
1808 tag (in its info table).  If it is evaluated, then it goes ahead and do
1809 the selection, and then behaves just as if the selector thunk was an
1810 indirection to the selected field.
1811 If it is not
1812 evaluated, it treats the selector thunk like any other thunk of that
1813 shape.  [Implementation notes.  
1814 Copying: only the evacuate routine needs to be special.
1815 Compacting: only the PRStart (marking) routine needs to be special.]
1816 \end{itemize}
1817
1818
1819 The only label associated with a thunk is its info table:
1820 \begin{description}
1821 \item[$f$@_info@] is $f$'s info table.
1822 \end{description}
1823
1824
1825 \subsubsection{Partial applications (PAPs)}\label{sect:PAP}
1826
1827 A partial application (PAP) represents a function applied to too few arguments.
1828 It is only built as a result of updating after an argument-satisfaction
1829 check failure.  A PAP has the following shape:
1830 \begin{center}
1831 \begin{tabular}{|l|l|l|l|}\hline
1832 {\em Fixed header}  & {\em No of arg words} & {\em Function closure} & {\em Arg stack} \\ \hline
1833 \end{tabular}
1834 \end{center}
1835 The ``arg stack'' is a copy of of the chunk of stack above the update
1836 frame; ``no of arg words'' tells how many words it consists of.  The
1837 function closure is (a pointer to) the closure for the function whose
1838 argument-satisfaction check failed.
1839
1840 There is just one standard form of PAP with @INFO_TYPE@ = @PAP@.
1841 There is just one info table too, called @PAP_info@.
1842 Its entry code simply copies the arg stack chunk back on top of the
1843 stack and enters the function closure.  (It has to do a stack overflow test first.)
1844
1845 There are no static PAPs.
1846
1847 \subsubsection{Indirections}
1848 \label{sect:IND}
1849 \label{sect:IND_OLDGEN}
1850
1851 Indirection closures just point to other closures. They are introduced
1852 when a thunk is updated to point to its value. 
1853 The entry code for all indirections simply enters the closure it points to.
1854
1855 There are several forms of indirection:
1856 \begin{description}
1857 \item[@IND@] is the vanilla, dynamically-allocated indirection.
1858 It is removed by the garbage collector. It has the following
1859 shape:
1860 \begin{center}
1861 \begin{tabular}{|l|l|l|}\hline
1862 {\em Fixed header} & {\em Target closure} \\ \hline
1863 \end{tabular}
1864 \end{center}
1865
1866 \item[@IND_OLDGEN@] is the indirection used to update an old-generation
1867 thunk. Its shape is like this:
1868 \begin{center}
1869 \begin{tabular}{|l|l|l|}\hline
1870 {\em Fixed header} & {\em Mutable link field} & {\em Target closure} \\ \hline
1871 \end{tabular}
1872 \end{center}
1873 It contains a {\em mutable link field} that is used to string together
1874 all old-generation indirections that might have a pointer into
1875 the new generation.
1876
1877
1878 \item[@IND_PERMANENT@ and @IND_OLDGEN_PERMANENT@.]
1879 for lexical profiling, it is necessary to maintain cost centre
1880 information in an indirection, so ``permanent indirections'' are
1881 retained forever.  Otherwise they are just like vanilla indirections.
1882 \note{If a permanent indirection points to another permanent
1883 indirection or a @CONST@ closure, it is possible to elide the indirection
1884 since it will have no effect on the profiler.}
1885 \note{Do we still need @IND@ and @IND_OLDGEN@
1886 in the profiling build, or can we just make
1887 do with one pair whose behaviour changes when profiling is built?}
1888
1889 \item[@IND_STATIC@] is used for overwriting CAFs when they have been
1890 evaluated.  Static indirections are not removed by the garbage
1891 collector; and are statically allocated outside the heap (and should
1892 stay there).  Their static object link field is used just as for
1893 @FUN_STATIC@ closures.
1894
1895 \begin{center}
1896 \begin{tabular}{|l|l|l|}
1897 \hline
1898 {\em Fixed header} & {\em Target closure} & {\em Static object link} \\
1899 \hline
1900 \end{tabular}
1901 \end{center}
1902
1903 \end{description}
1904
1905 \subsubsection{Activation Records}
1906
1907 Activation records are parts of the stack described by return address
1908 info tables (closures with @INFO_TYPE@ values of @RET_SMALL@,
1909 @RET_VEC_SMALL@, @RET_BIG@ and @RET_VEC_BIG@). They are described in
1910 section~\ref{sect:activation-records}.
1911
1912
1913 \subsubsection{Black holes, MVars and IVars}
1914 \label{sect:BH}
1915 \label{sect:MVAR}
1916 \label{sect:IVAR}
1917
1918 Black hole closures are used to overwrite closures currently being
1919 evaluated. They inform the garbage collector that there are no live
1920 roots in the closure, thus removing a potential space leak.  
1921
1922 Black holes also become synchronization points in the threaded world.
1923 They contain a pointer to a list of blocked threads to be awakened
1924 when the black hole is updated (or @NULL@ if the list is empty).
1925 \begin{center}
1926 \begin{tabular}{|l|l|l|}
1927 \hline 
1928 {\em Fixed header} & {\em Mutable link} & {\em Blocked thread link} \\
1929 \hline
1930 \end{tabular}
1931 \end{center}
1932 The {\em Blocked thread link} points to the TSO of the first thread
1933 waiting for the value of this thunk.  All subsequent TSOs in the list
1934 are linked together using their @TSO_LINK@ field.
1935
1936 When the blocking queue is non-@NULL@, the black hole must be added to
1937 the mutables list since the TSOs on the list may contain pointers into
1938 the new generation.  There is no need to clutter up the mutables list
1939 with black holes with empty blocking queues.
1940
1941 \ToDo{MVars}
1942
1943
1944 \subsubsection{FetchMes}\label{sect:FETCHME}
1945
1946 In the parallel systems, FetchMes are used to represent pointers into
1947 the global heap.  When evaluated, the value they point to is read from
1948 the global heap.
1949
1950 \ToDo{Describe layout}
1951
1952
1953 \subsection{Unpointed Objects}
1954
1955 A variable of unpointed type is always bound to a {\em value}, never to a {\em thunk}.
1956 For this reason, unpointed objects cannot be entered.
1957
1958 A {\em value} may be:
1959 \begin{itemize}
1960 \item {\em Boxed}, i.e.~represented indirectly by a pointer to a heap object (e.g.~foreign objects, arrays); or
1961 \item {\em Unboxed}, i.e.~represented directly by a bit-pattern in one or more registers (e.g.~@Int#@ and @Float#@).
1962 \end{itemize}
1963 All {\em pointed} values are {\em boxed}.  
1964
1965 \subsubsection{Immutable Objects}
1966 \label{sect:ARR_WORDS1}
1967 \label{sect:ARR_PTRS}
1968
1969 \begin{description}
1970 \item[@ARR_WORDS@] is a variable-sized object consisting solely of
1971 non-pointers.  It is used for arrays of all
1972 sorts of things (bytes, words, floats, doubles... it doesn't matter).
1973 \begin{center}
1974 \begin{tabular}{|c|c|c|c|}
1975 \hline
1976 {\em Fixed Hdr} & {\em No of non-pointers} & {\em Non-pointers\ldots}   \\ \hline
1977 \end{tabular}
1978 \end{center}
1979
1980 \item[@ARR_PTRS@] is an immutable, variable sized array of pointers.
1981 \begin{center}
1982 \begin{tabular}{|c|c|c|c|}
1983 \hline
1984 {\em Fixed Hdr} & {\em Mutable link} & {\em No of pointers} & {\em Pointers\ldots}      \\ \hline
1985 \end{tabular}
1986 \end{center}
1987 The mutable link is present so that we can easily freeze and thaw an
1988 array (by changing the header and adding/removing the array to the
1989 mutables list).
1990
1991 \end{description}
1992
1993 \subsubsection{Mutable Objects}
1994 \label{sect:mutables}
1995 \label{sect:ARR_WORDS2}
1996 \label{sect:MUTVAR}
1997 \label{sect:MUTARR_PTRS}
1998 \label{sect:MUTARR_PTRS_FROZEN}
1999
2000 Some of these objects are {\em mutable}; they represent objects which
2001 are explicitly mutated by Haskell code through the @ST@ monad.
2002 They're not used for thunks which are updated precisely once.
2003 Depending on the garbage collector, mutable closures may contain extra
2004 header information which allows a generational collector to implement
2005 the ``write barrier.''
2006
2007 \begin{description}
2008
2009 \item[@ARR_WORDS@] is also used to represent {\em mutable} arrays of
2010 bytes, words, floats, doubles, etc.  It's possible to use the same
2011 object type because even generational collectors don't need to
2012 distinguish them.
2013
2014 \item[@MUTVAR@] is a mutable variable.
2015 \begin{center}
2016 \begin{tabular}{|c|c|c|}
2017 \hline
2018 {\em Fixed Hdr} & {\em Mutable link} & {\em Pointer} \\ \hline
2019 \end{tabular}
2020 \end{center}
2021
2022 \item[@MUTARR_PTRS@] is a mutable array of pointers.
2023 Such an array may be {\em frozen}, becoming an @SM_MUTARR_PTRS_FROZEN@, with a
2024 different info-table.
2025 \begin{center}
2026 \begin{tabular}{|c|c|c|c|}
2027 \hline
2028 {\em Fixed Hdr} & {\em Mutable link} & {\em No of ptrs} & {\em Pointers\ldots} \\ \hline
2029 \end{tabular}
2030 \end{center}
2031
2032 \item[@MUTARR_PTRS_FROZEN@] is a frozen @MUTARR_PTRS@ closure.
2033 The garbage collector converts @MUTARR_PTRS_FROZEN@ to @ARR_PTRS@ as it removes them from
2034 the mutables list.
2035
2036 \end{description}
2037
2038
2039 \subsubsection{Foreign Objects}\label{sect:FOREIGN}
2040
2041 Here's what a ForeignObj looks like:
2042
2043 \begin{center}
2044 \begin{tabular}{|l|l|l|l|}
2045 \hline 
2046 {\em Fixed header} & {\em Data} & {\em Free Routine} & {\em Foreign object link} \\
2047 \hline
2048 \end{tabular}
2049 \end{center}
2050
2051 The @FreeRoutine@ is a reference to the finalisation routine to call
2052 when the @ForeignObj@ becomes garbage.  If @freeForeignObject@ is
2053 called on a Foreign Object, the @FreeRoutine@ is set to zero and the
2054 garbage collector will not attempt to call @FreeRoutine@ when the 
2055 object becomes garbage.
2056
2057 The Foreign object link is a link to the next foreign object in the
2058 list.  This list is traversed at the end of garbage collection: if an
2059 object is about to be deallocated (e.g.~it was not marked or
2060 evacuated), the free routine is called and the object is deleted from
2061 the list.  
2062
2063
2064 The remaining objects types are all administrative --- none of them may be entered.
2065
2066 \subsection{Thread State Objects (TSOs)}\label{sect:TSO}
2067
2068 In the multi-threaded system, the state of a suspended thread is
2069 packed up into a Thread State Object (TSO) which contains all the
2070 information needed to restart the thread and for the garbage collector
2071 to find all reachable objects.  When a thread is running, it may be
2072 ``unpacked'' into machine registers and various other memory locations
2073 to provide faster access.
2074
2075 Single-threaded systems don't really {\em need\/} TSOs --- but they do
2076 need some way to tell the storage manager about live roots so it is
2077 convenient to use a single TSO to store the mutator state even in
2078 single-threaded systems.
2079
2080 Rather than manage TSOs' alloc/dealloc, etc., in some {\em ad hoc}
2081 way, we instead alloc/dealloc/etc them in the heap; then we can use
2082 all the standard garbage-collection/fetching/flushing/etc machinery on
2083 them.  So that's why TSOs are ``heap objects,'' albeit very special
2084 ones.
2085 \begin{center}
2086 \begin{tabular}{|l|l|}
2087    \hline {\em Fixed header}
2088 \\ \hline @TSO_LINK@
2089 \\ \hline @TSO_WHATNEXT@
2090 \\ \hline @TSO_WHATNEXT_INFO@ 
2091 \\ \hline @TSO_STACK@ 
2092 \\ \hline {\em Exception Handlers}
2093 \\ \hline {\em Ticky Info}
2094 \\ \hline {\em Profiling Info}
2095 \\ \hline {\em Parallel Info}
2096 \\ \hline {\em GranSim Info}
2097 \\ \hline
2098 \end{tabular}
2099 \end{center}
2100 The contents of a TSO are:
2101 \begin{itemize}
2102
2103 \item A pointer (@TSO_LINK@) used to maintain a list of threads with a similar
2104   state (e.g.~all runable, all sleeping, all blocked on the same black
2105   hole, all blocked on the same MVar, etc.)
2106
2107 \item A word (@TSO_WHATNEXT@) which is in suspended threads to record
2108  how to awaken it.  This typically requires a program counter which is stored
2109  in the pointer @TSO_WHATNEXT_INFO@
2110
2111 \item A pointer (@TSO_STACK@) to the top stack block.
2112
2113 \item Optional information for ``Ticky Ticky'' statistics: @TSO_STK_HWM@ is
2114   the maximum number of words allocated to this thread.
2115
2116 \item Optional information for profiling: 
2117   @TSO_CCC@ is the current cost centre.
2118
2119 \item Optional information for parallel execution:
2120 \begin{itemize}
2121
2122 \item The types of threads (@TSO_TYPE@):
2123 \begin{description}
2124 \item[@T_MAIN@]     Must be executed locally.
2125 \item[@T_REQUIRED@] A required thread  -- may be exported.
2126 \item[@T_ADVISORY@] An advisory thread -- may be exported.
2127 \item[@T_FAIL@]     A failure thread   -- may be exported.
2128 \end{description}
2129
2130 \item I've no idea what else
2131
2132 \end{itemize}
2133
2134 \item Optional information for GranSim execution:
2135 \begin{itemize}
2136 \item locked         
2137 \item sparkname  
2138 \item started at         
2139 \item exported   
2140 \item basic blocks       
2141 \item allocs     
2142 \item exectime   
2143 \item fetchtime  
2144 \item fetchcount         
2145 \item blocktime  
2146 \item blockcount         
2147 \item global sparks      
2148 \item local sparks       
2149 \item queue              
2150 \item priority   
2151 \item clock          (gransim light only)
2152 \end{itemize}
2153
2154
2155 Here are the various queues for GrAnSim-type events.
2156 @
2157 Q_RUNNING   
2158 Q_RUNNABLE  
2159 Q_BLOCKED   
2160 Q_FETCHING  
2161 Q_MIGRATING 
2162 @
2163
2164 \end{itemize}
2165
2166 \subsection{Other weird objects}
2167 \label{sect:SPARK}
2168 \label{sect:BLOCKED_FETCH}
2169
2170 \begin{description}
2171 \item[@BlockedFetch@ heap objects (`closures')] (parallel only)
2172
2173 @BlockedFetch@s are inbound fetch messages blocked on local closures.
2174 They arise as entries in a local blocking queue when a fetch has been
2175 received for a local black hole.  When awakened, we look at their
2176 contents to figure out where to send a resume.
2177
2178 A @BlockedFetch@ closure has the form:
2179 \begin{center}
2180 \begin{tabular}{|l|l|l|l|l|l|}\hline
2181 {\em Fixed header} & link & node & gtid & slot & weight \\ \hline
2182 \end{tabular}
2183 \end{center}
2184
2185 \item[Spark Closures] (parallel only)
2186
2187 Spark closures are used to link together all closures in the spark pool.  When
2188 the current processor is idle, it may choose to speculatively evaluate some of
2189 the closures in the pool.  It may also choose to delete sparks from the pool.
2190 \begin{center}
2191 \begin{tabular}{|l|l|l|l|l|l|}\hline
2192 {\em Fixed header} & {\em Spark pool link} & {\em Sparked closure} \\ \hline
2193 \end{tabular}
2194 \end{center}
2195
2196
2197 \end{description}
2198
2199
2200 \subsection{Stack Objects}
2201 \label{sect:STACK_OBJECT}
2202 \label{sect:stacks}
2203
2204 These are ``stack objects,'' which are used in the threaded world as
2205 the stack for each thread is allocated from the heap in smallish
2206 chunks.  (The stack in the sequential world is allocated outside of
2207 the heap.)
2208
2209 Each reduction thread has to have its own stack space.  As there may
2210 be many such threads, and as any given one may need quite a big stack,
2211 a naive give-'em-a-big-stack-and-let-'em-run approach will cost a {\em
2212 lot} of memory.
2213
2214 Our approach is to give a thread a small stack space, and then link
2215 on/off extra ``chunks'' as the need arises.  Again, this is a
2216 storage-management problem, and, yet again, we choose to graft the
2217 whole business onto the existing heap-management machinery.  So stack
2218 objects will live in the heap, be garbage collected, etc., etc..
2219
2220 A stack object is laid out like this:
2221
2222 \begin{center}
2223 \begin{tabular}{|l|}
2224 \hline
2225 {\em Fixed header} 
2226 \\ \hline
2227 {\em Link to next stack object (0 for last)}
2228 \\ \hline
2229 {\em N, the payload size in words}
2230 \\ \hline
2231 {\em @Sp@ (byte offset from head of object)}
2232 \\ \hline
2233 {\em @Su@ (byte offset from head of object)}
2234 \\ \hline
2235 {\em Payload (N words)}
2236 \\ \hline
2237 \end{tabular}
2238 \end{center}
2239
2240 \ToDo{Are stack objects on the mutable list?}
2241
2242 The stack grows downwards, towards decreasing
2243 addresses.  This makes it easier to print out the stack
2244 when debugging, and it means that a return address is
2245 at the lowest address of the chunk of stack it ``knows about''
2246 just like an info pointer on a closure.
2247
2248 The garbage collector needs to be able to find all the
2249 pointers in a stack.  How does it do this?
2250
2251 \begin{itemize}
2252
2253 \item Within the stack there are return addresses, pushed
2254 by @case@ expressions.  Below a return address (i.e. at higher
2255 memory addresses, since the stack grows downwards) is a chunk
2256 of stack that the return address ``knows about'', namely the
2257 activation record of the currently running function.
2258
2259 \item Below each such activation record is a {\em pending-argument
2260 section}, a chunk of
2261 zero or more words that are the arguments to which the result
2262 of the function should be applied.  The return address does not
2263 statically
2264 ``know'' how many pending arguments there are, or their types.
2265 (For example, the function might return a result of type $\alpha$.)
2266
2267 \item Below each pending-argument section is another return address,
2268 and so on.  Actually, there might be an update frame instead, but we
2269 can consider update frames as a special case of a return address with
2270 a well-defined activation record.
2271
2272 \ToDo{Doesn't it {\em have} to be an update frame?  After all, the arg
2273 satisfaction check is @Su - Sp >= ...@.}
2274
2275 \end{itemize}
2276
2277 The game plan is this.  The garbage collector
2278 walks the stack from the top, traversing pending-argument sections and
2279 activation records alternately.  Next we discuss how it finds
2280 the pointers in each of these two stack regions.
2281
2282
2283 \subsubsection{Activation records}\label{sect:activation-records}
2284
2285 An {\em activation record} is a contiguous chunk of stack,
2286 with a return address as its first word, followed by as many
2287 data words as the return address ``knows about''.  The return
2288 address is actually a fully-fledged info pointer.  It points
2289 to an info table, replete with:
2290
2291 \begin{itemize}
2292 \item entry code (i.e. the code to return to).
2293 \item @INFO_TYPE@ is either @RET_SMALL/RET_VEC_SMALL@ or @RET_BIG/RET_VEC_BIG@, depending
2294 on whether the activation record has more than 32 data words (\note{64 for 8-byte-word architectures}) and on whether 
2295 to use a direct or a vectored return.
2296 \item @INFO_SM@ for @RET_SMALL@ is a bitmap telling the layout
2297 of the activation record, one bit per word.  The least-significant bit
2298 describes the first data word of the record (adjacent to the fixed
2299 header) and so on.  A ``@1@'' indicates a non-pointer, a ``@0@''
2300 indicates
2301 a pointer.  We don't need to indicate exactly how many words there
2302 are,
2303 because when we get to all zeros we can treat the rest of the 
2304 activation record as part of the next pending-argument region.
2305
2306 For @RET_BIG@ the @INFO_SM@ field points to a block of bitmap
2307 words, starting with a word that tells how many words are in
2308 the block.
2309
2310 \item @INFO_SRT@ is the Static Reference Table for the return
2311 address (Section~\ref{sect:srt}).
2312 \end{itemize}
2313
2314 The activation record is a fully fledged closure too.
2315 As well as an info pointer, it has all the other attributes of
2316 a fixed header (Section~\ref{sect:fixed-header}) including a saved cost
2317 centre which is reloaded when the return address is entered.
2318
2319 In other words, all the attributes of closures are needed for
2320 activation records, so it's very convenient to make them look alike.
2321
2322
2323 \subsubsection{Pending arguments}
2324
2325 So that the garbage collector can correctly identify pointers
2326 in pending-argument sections we explicitly tag all non-pointers.
2327 Every non-pointer in a pending-argument section is preceded
2328 (at the next lower memory word) by a one-word byte count that
2329 says how many bytes to skip over (excluding the tag word).
2330
2331 The garbage collector traverses a pending argument section from 
2332 the top (i.e. lowest memory address).  It looks at each word in turn:
2333
2334 \begin{itemize}
2335 \item If it is less than or equal to a small constant @MAX_STACK_TAG@
2336 then
2337 it treats it as a tag heralding zero or more words of non-pointers,
2338 so it just skips over them.
2339
2340 \item If it points to the code segment, it must be a return
2341 address, so we have come to the end of the pending-argument section.
2342
2343 \item Otherwise it must be a bona fide heap pointer.
2344 \end{itemize}
2345
2346
2347 \subsection{The Stable Pointer Table}\label{sect:STABLEPTR_TABLE}
2348
2349 A stable pointer is a name for a Haskell object which can be passed to
2350 the external world.  It is ``stable'' in the sense that the name does
2351 not change when the Haskell garbage collector runs---in contrast to
2352 the address of the object which may well change.
2353
2354 A stable pointer is represented by an index into the
2355 @StablePointerTable@.  The Haskell garbage collector treats the
2356 @StablePointerTable@ as a source of roots for GC.
2357
2358 In order to provide efficient access to stable pointers and to be able
2359 to cope with any number of stable pointers (eg $0 \ldots 100000$), the
2360 table of stable pointers is an array stored on the heap and can grow
2361 when it overflows.  (Since we cannot compact the table by moving
2362 stable pointers about, it seems unlikely that a half-empty table can
2363 be reduced in size---this could be fixed if necessary by using a
2364 hash table of some sort.)
2365
2366 In general a stable pointer table closure looks like this:
2367
2368 \begin{center}
2369 \begin{tabular}{|l|l|l|l|l|l|l|l|l|l|l|}
2370 \hline
2371 {\em Fixed header} & {\em No of pointers} & {\em Free} & $SP_0$ & \ldots & $SP_{n-1}$ 
2372 \\\hline
2373 \end{tabular}
2374 \end{center}
2375
2376 The fields are:
2377 \begin{description}
2378
2379 \item[@NPtrs@:] number of (stable) pointers.
2380
2381 \item[@Free@:] the byte offset (from the first byte of the object) of the first free stable pointer.
2382
2383 \item[$SP_i$:] A stable pointer slot.  If this entry is in use, it is
2384 an ``unstable'' pointer to a closure.  If this entry is not in use, it
2385 is a byte offset of the next free stable pointer slot.
2386
2387 \end{description}
2388
2389 When a stable pointer table is evacuated
2390 \begin{enumerate}
2391 \item the free list entries are all set to @NULL@ so that the evacuation
2392   code knows they're not pointers;
2393
2394 \item The stable pointer slots are scanned linearly: non-@NULL@ slots
2395 are evacuated and @NULL@-values are chained together to form a new free list.
2396 \end{enumerate}
2397
2398 There's no need to link the stable pointer table onto the mutable
2399 list because we always treat it as a root.
2400
2401
2402
2403 \section{The Storage Manager}
2404
2405 The generational collector remembers the depth of the last generation
2406 collected and the value of the heap pointer at the end of the last GC.
2407 If the mutator has not moved the heap pointer, that means that the
2408 amount of space recovered is insufficient to satisfy even one request
2409 and it is time to collect an older generation or report a heap overflow.
2410
2411 A deeper collection is also triggered when a minor collection fails to
2412 recover at least @...@ bytes of space.
2413
2414 When can a GC happen?
2415
2416 @
2417 - During updates (ie during returns)
2418 - When a heap check fails
2419 - When a stack check fails (concurrent system only)
2420 - When a context switch happens (concurrent system only)
2421
2422 When do heap checks occur?
2423 - Immediately after entering a thunk
2424 - Immediately after entering a case alternative
2425
2426 When do stack checks occur?
2427 - We calculate the worst-case stack usage of an entire
2428   thunk so there's no need to put a check inside each alternative.
2429 - Immediately after entering a thunk
2430   We can't make a similar worst-case calculation for heap usage
2431   because the heap isn't used in a stacklike manner so any
2432   evaluation inside a case might steal some of the heap we've
2433   checked for.
2434
2435 Concurrency
2436 - Threads can be blocked
2437 - Threads can be put to sleep
2438   - Heap may move while we sleep
2439   - Black holing may happen while we sleep (ie during GC)
2440 @
2441
2442 \subsection{The SM state}
2443
2444 Contains @Hp@, @HpLim@, @StablePtrTable@ plus version-specific info.
2445
2446 \begin{itemize}
2447
2448 \item Static Object list 
2449 \item Foreign Object list
2450 \item Stable Pointer Table
2451
2452 \end{itemize}
2453
2454 In addition, the generational collector requires:
2455
2456 \begin{itemize}
2457
2458 \item Old Generation Indirection list
2459 \item Mutables list --- list of mutable objects in the old generation.
2460 \item @OldLim@ --- the boundary between the generations
2461 \item Old Foreign Object list --- foreign objects in the old generation
2462
2463 \end{itemize}
2464
2465 It is passed a table of {\em roots\/} containing
2466
2467 \begin{itemize}
2468
2469 \item All runnable TSOs
2470
2471 \end{itemize}
2472
2473
2474 In the parallel system, there must be some extra magic associated with
2475 global GC.
2476
2477 \subsection{The SM interface}
2478
2479 @initSM@ finalizes any runtime parameters of the storage manager.
2480
2481 @exitSM@ does any cleaning up required by the storage manager before
2482 the program is executed. Its main purpose is to print any summary
2483 statistics.
2484
2485 @initHeap@ allocates the heap. It initialises the @hp@ and @hplim@
2486 fields of @sm@ to represent an empty heap for the compiled-in garbage
2487 collector.  It also initialises @CAFlist@ to be the empty list. If we
2488 are using Appel's collector it also initialises the @OldLim@ field.
2489 It also initialises the stable pointer table and the @ForeignObjList@
2490 (and @OldForeignObjList@) fields.
2491
2492 @collectHeap@ invokes the garbage collector.  @collectHeap@ requires
2493 all the fields of @sm@ to be initialised appropriately (from the
2494 STG-machine registers).  The following are identified as heap roots:
2495 \begin{itemize}
2496 \item The updated CAFs recorded in @CAFlist@.
2497 \item Any pointers found on the stack.
2498 \item All runnable and sleeping TSOs.
2499 \item The stable pointer table.
2500 \end{itemize}
2501
2502 There are two possible results from a garbage collection:
2503 \begin{description} 
2504 \item[@GC_FAIL@] 
2505 The garbage collector is unable to free up any more space.
2506
2507 \item[@GC_SUCCESS@]
2508 The garbage collector managed to free up more space.
2509
2510 \begin{itemize} 
2511 \item @hp@ and @hplim@ will indicate the new space available for
2512 allocation.
2513
2514 \item The elements of @CAFlist@ and the stable pointers will be
2515 updated to point to the new locations of the closures they reference.
2516
2517 \item Any members of @ForeignObjList@ which became garbage should have
2518 been reported (by calling their finalising routines; and the
2519 @(Old)ForeignObjList@ updated to contain only those Foreign objects
2520 which are still live.  
2521
2522 \end{itemize}
2523
2524 \end{description}
2525
2526
2527 %************************************************************************
2528 %*                                                                      *
2529 \subsection{``What really happens in a garbage collection?''}
2530 %*                                                                      *
2531 %************************************************************************
2532
2533 This is a brief tutorial on ``what really happens'' going to/from the
2534 storage manager in a garbage collection.
2535
2536 \begin{description}
2537 %------------------------------------------------------------------------
2538 \item[The heap check:]
2539
2540 [OLD-ISH: WDP]
2541
2542 If you gaze into the C output of GHC, you see many macros calls like:
2543 \begin{verbatim}
2544 HEAP_CHK_2PtrsLive((_FHS+2));
2545 \end{verbatim}
2546
2547 This expands into the C (roughly speaking...):
2548 @
2549 Hp = Hp + (_FHS+2);     /* optimistically move heap pointer forward */
2550
2551 GC_WHILE_OR_IF (HEAP_OVERFLOW_OP(Hp, HpLim) OR_INTERVAL_EXPIRED) {
2552         STGCALL2_GC(PerformGC, <liveness-bits>, (_FHS+2));
2553 }
2554 @
2555
2556 In the parallel world, where we will need to re-try the heap check,
2557 @GC_WHILE_OR_IF@ will be a ``while''; in the sequential world, it will
2558 be an ``if''.
2559
2560 The ``heap lookahead'' checks, which are similar and used for
2561 multi-precision @Integer@ ops, have some further complications.  See
2562 the commentary there (@StgMacros.lh@).
2563
2564 %------------------------------------------------------------------------
2565 \item[Into @callWrapper_GC@...:]
2566
2567 When we failed the heap check (above), we were inside the
2568 GCC-registerised ``threaded world.''  @callWrapper_GC@ is all about
2569 getting in and out of the threaded world.  On SPARCs, with register
2570 windows, the name of the game is not shifting windows until we have
2571 what we want out of the old one.  In tricky cases like this, it's best
2572 written in assembly language.
2573
2574 Performing a GC (potentially) means giving up the thread of control.
2575 So we must fill in the thread-state-object (TSO) [and its associated
2576 stk object] with enough information for later resumption:
2577 \begin{enumerate}
2578 \item
2579 Save the return address in the TSO's PC field.
2580 \item
2581 Save the machine registers used in the STG threaded world in their
2582 corresponding TSO fields.  We also save the pointer-liveness
2583 information in the TSO.
2584 \item
2585 The registers that are not thread-specific, notably @Hp@ and
2586 @HpLim@, are saved in the @StorageMgrInfo@ structure.
2587 \item
2588 Call the routine it was asked to call; in this example, call
2589 @PerformGC@ with arguments @<liveness>@ and @_FHS+2@ (some constant)...
2590
2591 \end{enumerate}
2592
2593 %------------------------------------------------------------------------
2594 \item[Into the heap overflow wrapper, @PerformGC@ [parallel]:]
2595
2596 Most information has already been saved in the TSO.
2597
2598 \begin{enumerate}
2599 \item
2600 The first argument (@<liveness>@, in our example) say what registers
2601 are live, i.e., are ``roots'' the storage manager needs to know.
2602 \begin{verbatim}
2603 StorageMgrInfo.rootno   = 2;
2604 StorageMgrInfo.roots[0] = (P_) Ret1_SAVE;
2605 StorageMgrInfo.roots[1] = (P_) Ret2_SAVE;
2606 \end{verbatim}
2607
2608 \item
2609 We move the heap-pointer back [we had optimistically
2610 advanced it, in the initial heap check]
2611
2612 \item 
2613 We load up the @smInfo@ data from the STG registers' @*_SAVE@ locations.
2614
2615 \item
2616 We mark on the scheduler's big ``blackboard'' that a GC is
2617 required.
2618
2619 \item
2620 We reschedule, i.e., this thread gives up control.  (The scheduler
2621 will presumably initiate a garbage-collection, but it may have to do
2622 any number of other things---flushing, for example---before ``normal
2623 execution'' resumes; and it most certainly may not be this thread that
2624 resumes at that point!)
2625 \end{enumerate}
2626
2627 IT IS AT THIS POINT THAT THE WORLD IS COMPLETELY TIDY.
2628
2629 %------------------------------------------------------------------------
2630 \item[Out of @callWrapper_GC@ [parallel]:]
2631
2632 When this thread is finally resumed after GC (and who knows what
2633 else), it will restart by the normal enter-TSO/enter-stack-object
2634 sequence, which has the effect of re-loading the registers, etc.,
2635 (i.e., restoring the state).
2636
2637 Because the address we saved in the TSO's PC field was that at the end
2638 of the heap check, and because the check is a while-loop in the
2639 parallel system, we will now loop back around, and make sure there is
2640 enough space before continuing.
2641 \end{description}
2642
2643
2644
2645 \subsection{Static Reference Tables (SRTs)}
2646 \label{sect:srt}
2647 \label{sect:CAF}
2648 \label{sect:static-objects}
2649
2650 In the above, we assumed that objects always contained pointers to all
2651 their free variables.  In fact, this isn't quite true: GHC omits
2652 pointers to top-level objects and allocates their closures in static
2653 memory.  This optimisation reduces the number of free variables in
2654 heap objects - reducing memory usage and the effort needed to put them
2655 into heap objects.  However, this optimisation comes at a cost: we
2656 need to complicate the garbage collector with machinery for tracing
2657 these static references.
2658
2659 Early versions of GHC used a very simple algorithm: it treated all
2660 static objects as roots.  This is safe in the sense that no object is
2661 ever deallocated if there's a chance that it might be required later
2662 but can lead to some terrible space leaks.  For example, this program
2663 ought to be able to run in constant space but, because @xs@ is never
2664 deallocated, it runs in linear space.
2665
2666 @
2667 main = print xs
2668 xs = [1..]
2669 @
2670
2671 The correct behaviour is for the garbage collector to keep a static
2672 object alive iff it might be required later in execution.  That is, if
2673 it is reachable from any live heap objects {\em or\/} from any return
2674 addresses found on the stack or from the current program counter.
2675 Since it is obviously infeasible for the garbage collector to scan
2676 machine code looking for static references, the code generator must
2677 generate a table of all static references in any piece of code (and we
2678 must place a pointer to this table next to any piece of code we
2679 generate).
2680
2681 Here's what the SRT has to contain:
2682
2683 @
2684 ...
2685 @
2686
2687 Here's how we represent it:
2688
2689 @
2690 ...
2691 must be able to handle 0 references well
2692 @
2693
2694 @
2695 Other trickery:
2696 o The CAF list
2697 o The scavenge list
2698 o Generational GC trickery
2699 @
2700
2701 \subsection{Space leaks and black holes}
2702 \label{sect:black-hole}
2703
2704 \iffalse
2705
2706 \ToDo{Insert text stolen from update paper}
2707
2708 \else
2709
2710 A program exhibits a {\em space leak} if it retains storage that is
2711 sure not to be used again.  Space leaks are becoming increasingly
2712 common in imperative programs that @malloc@ storage and fail
2713 subsequently to @free@ it.  They are, however, also common in
2714 garbage-collected systems, especially where lazy evaluation is
2715 used.[.wadler leak, runciman heap profiling jfp.]
2716
2717 Quite a bit of experience has now accumulated suggesting that
2718 implementors must be very conscientious about avoiding gratuitous
2719 space leaks --- that is, ones which are an accidental artefact of some
2720 implementation technique.[.appel book.]  The update mechanism is
2721 a case in point, as <.jones jfp leak.> points out.  Consider a thunk for
2722 the expression
2723 @
2724   let xs = [1..1000] in last xs
2725 @
2726 where @last@ is a function that returns the last element of its
2727 argument list.  When the thunk is entered it will call @last@, which
2728 will consume @xs@ until it finds the last element.  Since the list
2729 @[1..1000]@ is produced lazily one might reasonably expect the
2730 expression to evaluate in constant space.  But {\em until the moment
2731 of update, the thunk itself still retains a pointer to the beginning
2732 of the list @xs@}.  So, until the update takes place the whole list
2733 will be retained!
2734
2735 Of course, this is completely gratuitous.  The pointer to @xs@ in the
2736 thunk will never be used again.  In <.peyton stock hardware.> the solution to
2737 this problem that we advocated was to overwrite a thunk's info with a
2738 fixed ``black hole'' info pointer, {\em at the moment of entry}.  The
2739 storage management information attached to a black-hole info pointer
2740 tells the garbage collector that the closure contains no pointers,
2741 thereby plugging the space leak.
2742
2743 \subsubsection{Lazy black-holing}
2744
2745 Black-holing is a well-known idea.  The trouble is that it is
2746 gallingly expensive.  To avoid the occasional space leak, for every
2747 single thunk entry we have to load a full-word literal constant into a
2748 register (often two instructions) and then store that register into a
2749 memory location.  
2750
2751 Fortunately, this cost can easily be avoided.  The
2752 idea is simple: {\em instead of black-holing every thunk on entry,
2753 wait until the garbage collector is called, and then black-hole all
2754 (and only) the thunks whose evaluation is in progress at that moment}.
2755 There is no benefit in black-holing a thunk that is updated before
2756 garbage collection strikes!  In effect, the idea is to perform the
2757 black-holing operation lazily, only when it is needed.  This
2758 dramatically cuts down the number of black-holing operations, as our
2759 results show {\em forward ref}.
2760
2761 How can we find all the thunks whose evaluation is in progress?  They
2762 are precisely the ones for which update frames are on the stack.  So
2763 all we need do is find all the update frames (via the @Su@ chain) and
2764 black-hole their thunks right at the start of garbage collection.
2765 Notice that it is not enough to refrain from treating update frames as
2766 roots: firstly because the thunks to which they point may need to be
2767 moved in a copying collector, but more importantly because the thunk
2768 might be accessible via some other route.
2769
2770 \subsubsection{Detecting loops}
2771
2772 Black-holing has a second minor advantage: evaluation of a thunk whose
2773 value depends on itself will cause a black hole closure to be entered,
2774 which can cause a suitable error message to be displayed. For example,
2775 consider the definition
2776 @
2777   x = 1+x
2778 @
2779 The code to evaluate @x@'s right hand side will evaluate @x@.  In the
2780 absence of black-holing, the result will be a stack overflow, as the
2781 evaluator repeatedly pushes a return address and enters @x@.  If
2782 thunks are black-holed on entry, then this infinite loop can be caught
2783 almost instantly.
2784
2785 With our new method of lazy black-holing, a self-referential program
2786 might cause either stack overflow or a black-hole error message,
2787 depending on exactly when garbage collection strikes.  It is quite
2788 easy to conceal these differences, however.  If stack overflow occurs,
2789 all we need do is examine the update frames on the stack to see if
2790 more than one refers to the same thunk.  If so, there is a loop that
2791 would have been detected by eager black-holing.
2792
2793 \subsubsection{Lazy locking}
2794 \label{sect:lock}
2795
2796 In a parallel implementation, it is necessary somehow to ``lock'' a
2797 thunk that is under evaluation, so that other parallel evaluators
2798 cannot simultaneously evaluate it and thereby duplicate work.
2799 Instead, an evaluator that enters a locked thunk should be blocked,
2800 and made runnable again when the thunk is updated.
2801
2802 This locking is readily arranged in the same way as black-holing, by
2803 overwriting the thunk's info pointer with a special ``locked'' info
2804 pointer, at the moment of entry.  If another evaluator enters the
2805 thunk before it has been updated, it will land in the entry code for
2806 the ``locked'' info pointer, which blocks the evaluator and queues it
2807 on the locked thunk.
2808
2809 The details are given by <.portable parallel trinder.>.  However, the close similarity
2810 between locking and black holing suggests the following question: can
2811 locking be done lazily too?  The answer is that it can, except that
2812 locking can be postponed only until the next {\em context switch},
2813 rather than the next {\em garbage collection}.  We are assuming here
2814 that the parallel implementation does not use shared memory to allow
2815 two processors to access the same closure.  If such access is
2816 permitted then every thunk entry requires a hardware lock, and becomes
2817 much too expensive.
2818
2819 Is lazy locking worth while, given that it requires extra work every
2820 context switch?  We believe it is, because contexts switches are
2821 relatively infrequent, and thousands of thunk-entries typically take
2822 place between each.
2823
2824 {\em Measurements elsewhere.  Omit this section? If so, fix cross refs to here.}
2825
2826 \fi
2827
2828
2829 \subsection{Squeezing identical updates}
2830
2831 \iffalse
2832
2833 \ToDo{Insert text stolen from update paper}
2834
2835 \else
2836
2837 Consider the following Haskell definition of the standard
2838 function @partition@ that divides a list into two, those elements
2839 that satisfy a predicate @p@ and those that do not:
2840 @
2841   partition :: (a->Bool) -> [a] -> ([a],[a])
2842   partition p [] = ([],[])
2843   partition p (x:xs) = if p x then (x:ys, zs)
2844                               else (ys, x:zs)
2845                      where
2846                        (ys,zs) = partition p xs
2847 @
2848 By the time this definition has been desugared, it looks like this:
2849 @
2850   partition p xs
2851     = case xs of
2852         [] -> ([],[])
2853         (x:xs) -> let
2854                     t = partition p xs
2855                     ys = fst t
2856                     zs = snd t
2857                   in
2858                   if p x then (x:ys,zs)
2859                          else (ys,x:zs)
2860 @
2861 Lazy evaluation demands that the recursive call is bound to an
2862 intermediate variable, @t@, from which @ys@ and @zs@ are lazily
2863 selected. (The functions @fst@ and @snd@ select the first and second
2864 elements of a pair, respectively.)
2865
2866 Now, suppose that @partition@ is applied to a list @[x1,x2]@,
2867 all of whose
2868 elements satisfy @p@.  We can get a good idea of what will happen
2869 at runtime by unrolling the recursion a few times in our heads.
2870 Unrolling once, and remembering that @(p x1)@ is @True@, we get this:
2871 @
2872   partition p [x1,x2]
2873 =
2874   let t1 = partition [x2]
2875       ys1 = fst t1
2876       zs1 = snd t1
2877   in (x1:ys1, zs1)
2878 @
2879 Unrolling the rest of the way gives this:
2880 @
2881   partition p [x1,x2]
2882 =
2883   let t2  = ([],[])
2884       ys2 = fst t2
2885       zs2 = snd t2
2886       t1  = (x2:ys2,zs2)
2887       ys1 = fst t1
2888       zs1 = snd t1
2889    in (x1:ys1,zs1)
2890 @
2891 Now consider what happens if @zs1@ is evaluated.  It is bound to a
2892 thunk, which will push an update frame before evaluating the
2893 expression @snd t1@.  This expression in turn forces evaluation of
2894 @zs2@, which pushes an update frame before evaluating @snd t2@.
2895 Indeed the stack of update frames will grow as deep as the list is
2896 long when @zs1@ is evaluated.  This is rather galling, since all the
2897 thunks @zs1@, @zs2@, and so on, have the same value.
2898
2899 \ToDo{Describe the state-transformer case in which we get a space leak from
2900 pending update frames.}
2901
2902 The solution is simple.  The garbage collector, which is going to traverse the
2903 update stack in any case, can easily identify two update frames that are directly
2904 on top of each other.  The second of these will update its target with the same
2905 value as the first.  Therefore, the garbage collector can perform the update 
2906 right away, by overwriting one update target with an indirection to the second,
2907 and eliminate the corresponding update frame.  In this way ever-growing stacks of
2908 update frames are reduced to a single representative at garbage collection time.
2909 If this is done at the start of garbage collection then, if it turns out that
2910 some of these update targets are garbage they will be collected right away.
2911
2912 \fi
2913
2914 \subsection{Space leaks and selectors}
2915
2916 \iffalse
2917
2918 \ToDo{Insert text stolen from update paper}
2919
2920 \else
2921
2922 In 1987, Wadler identified an important source of space leaks in
2923 lazy functional programs.  Consider the Haskell function definition:
2924 @
2925   f p = (g1 a, g2 b) where (a,b) = p
2926 @
2927 The pattern-matching in the @where@ clause is known as
2928 {\em lazy pattern-matching}, because it is performed only if @a@
2929 or @b@ is actually evaluated.  The desugarer translates lazy pattern matching
2930 to the use of selectors, @fst@ and @snd@ in this case:
2931 @
2932   f p = let a = fst p
2933             b = snd p
2934         in
2935         (b, a)
2936 @
2937 Now suppose that the second component of the pair @(f p)@, namely @a@,
2938 is evaluated and discarded, but the first is not although it remains
2939 reachable.  The garbage collector will find that the thunk for @b@ refers
2940 to @p@ and hence to @a@.  Thus, although @a@ cannot ever be used again, its
2941 space is retained.  It turns out that this space leak can have a very bad effect
2942 indeed on a program's space behaviour (Section~\ref{sect:selector-results}).
2943
2944 Wadler's paper also proposed a solution: if the garbage collector
2945 encounters a thunk of the form @snd p@, where @p@ is evaluated, then
2946 the garbage collector should perform the selection and overwrite the
2947 thunk with a pointer to the second component of the pair.  In effect, the
2948 garbage collector thereby performs a bounded amount of as-yet-undemanded evaluation
2949 in the hope of improving space behaviour.
2950 We implement this idea directly, by making the garbage collector
2951 eagerly execute all selector thunks\footnote{A word of caution: it is rather easy 
2952 to make a mistake in the implementation, especially if the garbage collector
2953 uses pointer reversal to traverse the reachable graph.},
2954 with results 
2955 reported in Section~\ref{sect:THUNK_SEL}.
2956
2957 One could easily imagine generalisations of this idea, with the garbage 
2958 collector performing bounded amounts of space-saving work.  One example is
2959 this:
2960 @
2961   f x []     = (x,x)
2962   f x (y:ys) = f (x+1) ys
2963 @
2964 Most lazy evaluators will build up a chain of thunks for the accumulating
2965 parameter, @x@, each of which increments @x@.  It is not safe to evaluate
2966 any of these thunks eagerly, since @f@ is not strict in @x@, and we know nothing
2967 about the value of @x@ passed in the initial call to @f@.
2968 On the other hand, if the garbage collector found a thunk @(x+1)@ where
2969 @x@ happened to be evaluated, then it could ``execute'' it eagerly.
2970 If done carefully, the entire chain could be eliminated in a single
2971 garbage collection.   We have not (yet) implemented this idea.
2972 A very similar idea, dubbed ``stingy evaluation'', is described 
2973 by <.stingy.>.
2974
2975 <.sparud lazy pattern matching.> describes another solution to the
2976 lazy-pattern-matching
2977 problem.  His solution involves adding code to the two thunks for
2978 @a@ and @b@ so that if either is evaluated it arranges to update the
2979 other as well as itself.  The garbage-collector solution is a little
2980 more general, since it applies whether or not the selectors were
2981 generated by lazy pattern matching, and in our setting it was easier
2982 to implement than Sparud's.
2983
2984 \fi
2985
2986
2987 \subsection{Internal workings of the Compacting Collector}
2988
2989 \subsection{Internal workings of the Copying Collector}
2990
2991 \subsection{Internal workings of the Generational Collector}
2992
2993
2994 \section{Dynamic Linking}
2995
2996 \section{Profiling}
2997
2998 Registering costs centres looks awkward - can we tidy it up?
2999
3000 \section{Parallelism}
3001
3002 Something about global GC, inter-process messages and fetchmes.
3003
3004 \section{Debugging}
3005
3006 \section{Ticky Ticky profiling}
3007
3008 Measure what proportion of ...:
3009 \begin{itemize}
3010 \item
3011 ... Enters are to data values, function values, thunks.
3012 \item
3013 ... allocations are for data values, functions values, thunks.
3014 \item
3015 ... updates are for data values, function values.
3016 \item
3017 ... updates ``fit''
3018 \item
3019 ... return-in-heap (dynamic)
3020 \item
3021 ... vectored return (dynamic)
3022 \item
3023 ... updates are wasted (never re-entered).
3024 \item
3025 ... constructor returns get away without hitting an update.
3026 \end{itemize}
3027
3028 %************************************************************************
3029 %*                                                                      *
3030 \subsubsection[ticky-stk-heap-use]{Stack and heap usage}
3031 %*                                                                      *
3032 %************************************************************************
3033
3034 Things we are interested in here:
3035 \begin{itemize}
3036 \item
3037 How many times we do a heap check and move @Hp@; comparing this with
3038 the allocations gives an indication of how many things we get per trip
3039 to the well:
3040
3041 If we do a ``heap lookahead,'' we haven't really allocated any
3042 heap, so we need to undo the effects of an @ALLOC_HEAP@:
3043
3044 \item
3045 The stack high-water mark.
3046
3047 \item
3048 Re-use of stack slots, and stubbing of stack slots:
3049
3050 \end{itemize}
3051
3052 %************************************************************************
3053 %*                                                                      *
3054 \subsubsection[ticky-allocs]{Allocations}
3055 %*                                                                      *
3056 %************************************************************************
3057
3058 We count things every time we allocate something in the dynamic heap.
3059 For each, we count the number of words of (1)~``admin'' (header),
3060 (2)~good stuff (useful pointers and data), and (3)~``slop'' (extra
3061 space, in hopes it will allow an in-place update).
3062
3063 The first five macros are inserted when the compiler generates code
3064 to allocate something; the categories correspond to the @ClosureClass@
3065 datatype (manifest functions, thunks, constructors, big tuples, and
3066 partial applications).
3067
3068 We may also allocate space when we do an update, and there isn't
3069 enough space.  These macros suffice (for: updating with a partial
3070 application and a constructor):
3071
3072 In the threaded world, we allocate space for the spark pool, stack objects,
3073 and thread state objects.
3074
3075 The histogrammy bit is fairly straightforward; the @-2@ is: one for
3076 0-origin C arrays; the other one because we do {\em no} one-word
3077 allocations, so we would never inc that histogram slot; so we shift
3078 everything over by one.
3079
3080 Some hard-to-account-for words are allocated by/for primitives,
3081 includes Integer support.  @ALLOC_PRIM2@ tells us about these.  We
3082 count everything as ``goods'', which is not strictly correct.
3083 (@ALLOC_PRIM@ is the same sort of stuff, but we know the
3084 admin/goods/slop breakdown.)
3085
3086 %************************************************************************
3087 %*                                                                      *
3088 \subsubsection[ticky-enters]{Enters}
3089 %*                                                                      *
3090 %************************************************************************
3091
3092 We do more magical things with @ENT_FUN_DIRECT@.  Besides simply knowing
3093 how many ``fast-entry-point'' enters there were, we'd like {\em simple}
3094 information about where those enters were, and the properties thereof.
3095 @
3096 struct ent_counter {
3097     unsigned    registeredp:16, /* 0 == no, 1 == yes */
3098                 arity:16,       /* arity (static info) */
3099                 Astk_args:16,   /* # of args off A stack */
3100                 Bstk_args:16;   /* # of args off B stack */
3101                                 /* (rest of args are in registers) */
3102     StgChar     *f_str;         /* name of the thing */
3103     StgChar     *f_arg_kinds;   /* info about the args types */
3104     StgChar     *wrap_str;      /* name of its wrapper (if any) */
3105     StgChar     *wrap_arg_kinds;/* info about the orig wrapper's arg types */
3106     I_          ctr;            /* the actual counter */
3107     struct ent_counter *link;   /* link to chain them all together */
3108 };
3109 @
3110
3111 %************************************************************************
3112 %*                                                                      *
3113 \subsubsection[ticky-returns]{Returns}
3114 %*                                                                      *
3115 %************************************************************************
3116
3117 Whenever a ``return'' occurs, it is returning the constituent parts of
3118 a data constructor.  The parts can be returned either in registers, or
3119 by allocating some heap to put it in (the @ALLOC_*@ macros account for
3120 the allocation).  The constructor can either be an existing one
3121 (@*OLD*@) or we could have {\em just} figured out this stuff
3122 (@*NEW*@).
3123
3124 Here's some special magic that Simon wants [edited to match names
3125 actually used]:
3126
3127 @
3128 From: Simon L Peyton Jones <simonpj>
3129 To: partain, simonpj
3130 Subject: counting updates
3131 Date: Wed, 25 Mar 92 08:39:48 +0000
3132
3133 I'd like to count how many times we update in place when actually Node
3134 points to the thing.  Here's how:
3135
3136 @RET_OLD_IN_REGS@ sets the variable @ReturnInRegsNodeValid@ to @True@;
3137 @RET_NEW_IN_REGS@ sets it to @False@.
3138
3139 @RET_SEMI_???@ sets it to??? ToDo [WDP]
3140
3141 @UPD_CON_IN_PLACE@ tests the variable, and increments @UPD_IN_PLACE_COPY_ctr@
3142 if it is true.
3143
3144 Then we need to report it along with the update-in-place info.
3145 @
3146
3147
3148 Of all the returns (sum of four categories above), how many were
3149 vectored?  (The rest were obviously unvectored).
3150
3151 %************************************************************************
3152 %*                                                                      *
3153 \subsubsection[ticky-update-frames]{Update frames}
3154 %*                                                                      *
3155 %************************************************************************
3156
3157 These macros count up the following update information.
3158
3159 \begin{tabular}{|l|l|} \hline
3160 Macro                   &       Counts                                  \\ \hline
3161                         &                                               \\
3162 @UPDF_STD_PUSHED@       &       Update frame pushed                     \\
3163 @UPDF_CON_PUSHED@       &       Constructor update frame pushed         \\
3164 @UPDF_HOLE_PUSHED@      &       An update frame to update a black hole  \\
3165 @UPDF_OMITTED@          &       A thunk decided not to push an update frame \\
3166                         &       (all subsets of @ENT_THK@)              \\
3167 @UPDF_RCC_PUSHED@       &       Cost Centre restore frame pushed        \\
3168 @UPDF_RCC_OMITTED@      &       Cost Centres not required -- not pushed \\\hline
3169 \end{tabular}
3170
3171 %************************************************************************
3172 %*                                                                      *
3173 \subsubsection[ticky-updates]{Updates}
3174 %*                                                                      *
3175 %************************************************************************
3176
3177 These macros record information when we do an update.  We always
3178 update either with a data constructor (CON) or a partial application
3179 (PAP).
3180
3181 \begin{tabular}{|l|l|}\hline
3182 Macro                   &       Where                                           \\ \hline
3183                         &                                                       \\
3184 @UPD_EXISTING@          &       Updating with an indirection to something       \\
3185                         &       already in the heap                             \\
3186 @UPD_SQUEEZED@          &       Same as @UPD_EXISTING@ but because              \\
3187                         &       of stack-squeezing                              \\
3188 @UPD_CON_W_NODE@        &       Updating with a CON: by indirecting to Node     \\
3189 @UPD_CON_IN_PLACE@      &       Ditto, but in place                             \\
3190 @UPD_CON_IN_NEW@        &       Ditto, but allocating the object                \\
3191 @UPD_PAP_IN_PLACE@      &       Same, but updating w/ a PAP                     \\
3192 @UPD_PAP_IN_NEW@        &                                                       \\\hline
3193 \end{tabular}
3194
3195 %************************************************************************
3196 %*                                                                      *
3197 \subsubsection[ticky-selectors]{Doing selectors at GC time}
3198 %*                                                                      *
3199 %************************************************************************
3200
3201 @GC_SEL_ABANDONED@: we could've done the selection, but we gave up
3202 (e.g., to avoid overflowing the C stack); @GC_SEL_MINOR@: did a
3203 selection in a minor GC; @GC_SEL_MAJOR@: ditto, but major GC.
3204
3205
3206
3207 \section{History}
3208
3209 We're nuking the following:
3210
3211 \begin{itemize}
3212 \item
3213   Two stacks
3214
3215 \item
3216   Return in registers.
3217   This lets us remove update code pointers from info tables,
3218   removes the need for phantom info tables, simplifies 
3219   semi-tagging, etc.
3220
3221 \item
3222   Threaded GC.
3223   Careful analysis suggests that it doesn't buy us very much
3224   and it is hard to work with.
3225
3226   Eliminating threaded GCs eliminates the desire to share SMReps
3227   so they are (once more) part of the Info table.
3228
3229 \item
3230   RetReg.
3231   Doesn't buy us anything on a register-poor architecture and
3232   isn't so important if we have semi-tagging.
3233
3234 @
3235     - Probably bad on register poor architecture 
3236     - Can avoid need to write return address to stack on reg rich arch.
3237       - when a function does a small amount of work, doesn't 
3238         enter any other thunks and then returns.
3239         eg entering a known constructor (but semitagging will catch this)
3240     - Adds complications
3241 @
3242
3243 \item
3244   Update in place
3245
3246   This lets us drop CONST closures and CHARLIKE closures (assuming we
3247   don't support Unicode).  The only point of these closures was to 
3248   avoid updating with an indirection.
3249
3250   We also drop @MIN_UPD_SIZE@ --- all we need is space to insert an
3251   indirection or a black hole.
3252
3253 \item
3254   STATIC SMReps are now called CONST
3255
3256 \item
3257   @SM_MUTVAR@ is new
3258
3259 \item The profiling ``kind'' field is now encoded in the @INFO_TYPE@ field.
3260 This identifies the general sort of the closure for profiling purposes.
3261
3262 \item Various papers describe deleting update frames for unreachable objects.
3263   This has never been implemented and we don't plan to anytime soon.
3264
3265 \end{itemize}
3266
3267 \section{Old tricks}
3268
3269 @CAF@ indirections:
3270
3271 These are statically defined closures which have been updated with a
3272 heap-allocated result.  Initially these are exactly the same as a
3273 @STATIC@ closure but with special entry code. On entering the closure
3274 the entry code must:
3275
3276 \begin{itemize}
3277 \item Allocate a black hole in the heap which will be updated with
3278       the result.
3279 \item Overwrite the static closure with a special @CAF@ indirection.
3280
3281 \item Link the static indirection onto the list of updated @CAF@s.
3282 \end{itemize}
3283
3284 The indirection and the link field require the initial @STATIC@
3285 closure to be of at least size @MIN_UPD_SIZE@ (excluding the fixed
3286 header).
3287
3288 @CAF@s are treated as special garbage collection roots.  These roots
3289 are explicitly collected by the garbage collector, since they may
3290 appear in code even if they are not linked with the main heap.  They
3291 consequently represent potentially enormous space-leaks.  A @CAF@
3292 closure retains a fixed location in statically allocated data space.
3293 When updated, the contents of the @CAF@ indirection are changed to
3294 reflect the new closure. @CAF@ indirections require special garbage
3295 collection code.
3296
3297 \section{Old stuff about SRTs}
3298
3299 Garbage collection of @CAF@s is tricky.  We have to cope with explicit
3300 collection from the @CAFlist@ as well as potential references from the
3301 stack and heap which will cause the @CAF@ evacuation code to be
3302 called.  They are treated like indirections which are shorted out.
3303 However they must also be updated to point to the new location of the
3304 new closure as the @CAF@ may still be used by references which
3305 reside in the code.
3306
3307 {\bf Copying Collection}
3308
3309 A first scheme might use evacuation code which evacuates the reference
3310 and updates the indirection. This is no good as subsequent evacuations
3311 will result in an already evacuated closure being evacuated. This will
3312 leave a forward reference in to-space!
3313
3314 An alternative scheme evacuates the @CAFlist@ first. The closures
3315 referenced are evacuated and the @CAF@ indirection updated to point to
3316 the evacuated closure. The @CAF@ evacuation code simply returns the
3317 updated indirection pointer --- the pointer to the evacuated closure.
3318 Unfortunately the closure the @CAF@ references may be a static
3319 closure, in fact, it may be another @CAF@. This will cause the second
3320 @CAF@'s evacuation code to be called before the @CAF@ has been
3321 evacuated, returning an unevacuated pointer.
3322
3323 Another scheme leaves updating the @CAF@ indirections to the end of
3324 the garbage collection.  All the references are evacuated and
3325 scavenged as usual (including the @CAFlist@). Once collection is
3326 complete the @CAFlist@ is traversed updating the @CAF@ references with
3327 the result of evacuating the referenced closure again. This will
3328 immediately return as it must be a forward reference, a static
3329 closure, or a @CAF@ which will indirect by evacuating its reference.
3330
3331 The crux of the problem is that the @CAF@ evacuation code needs to
3332 know if its reference has already been evacuated and updated. If not,
3333 then the reference can be evacuated, updated and returned safely
3334 (possibly evacuating another @CAF@). If it has, then the updated
3335 reference can be returned. This can be done using two @CAF@
3336 info-tables. At the start of a collection the @CAFlist@ is traversed
3337 and set to an internal {\em evacuate and update} info-table. During
3338 collection, evacution of such a @CAF@ also results in the info-table
3339 being reset back to the standard @CAF@ info-table. Thus subsequent
3340 evacuations will simply return the updated reference. On completion of
3341 the collection all @CAF@s will have {\em return reference} info-tables
3342 again.
3343
3344 This is the scheme we adopt. A @CAF@ indirection has evacuation code
3345 which returns the evacuated and updated reference. During garbage
3346 collection, all the @CAF@s are overwritten with an internal @CAF@ info
3347 table which has evacuation code which performs this evacuate and
3348 update and restores the original @CAF@ code. At some point during the
3349 collection we must ensure that all the @CAF@s are indeed evacuated.
3350
3351 The only potential problem with this scheme is a cyclic list of @CAF@s
3352 all directly referencing (possibly via indirections) another @CAF@!
3353 Evacuation of the first @CAF@ will fail in an infinite loop of @CAF@
3354 evacuations. This is solved by ensuring that the @CAF@ info-table is
3355 updated to a {\em return reference} info-table before performing the
3356 evacuate and update. If this {\em return reference} evacuation code is
3357 called before the actual evacuation is complete it must be because
3358 such a cycle of references exists. Returning the still unevacuated
3359 reference is OK --- all the @CAF@s will now reference the same
3360 @CAF@ which will reference itself! Construction of such a structure
3361 indicates the program must be in an infinite loop.
3362
3363 {\bf Compacting Collector}
3364
3365 When shorting out a @CAF@, its reference must be marked. A first
3366 attempt might explicitly mark the @CAF@s, updating the reference with
3367 the marked reference (possibly short circuting indirections). The
3368 actual @CAF@ marking code can indicate that they have already been
3369 marked (though this might not have actually been done yet) and return
3370 the indirection pointer so it is shorted out. Unfortunately the @CAF@
3371 reference might point to an indirection which will be subsequently
3372 shorted out. Rather than returning the @CAF@ reference we treat the
3373 @CAF@ as an indirection, calling the mark code of the reference, which
3374 will return the appropriately shorted reference.
3375
3376 Problem: Cyclic list of @CAF@s all directly referencing (possibly via
3377 indirections) another @CAF@!
3378
3379 Before compacting, the locations of the @CAF@ references are
3380 explicitly linked to the closures they reference (if they reference
3381 heap allocated closures) so that the compacting process will update
3382 them to the closure's new location. Unfortunately these locations'
3383 @CAF@ indirections are static.  This causes premature termination
3384 since the test to find the info pointer at the end of the location
3385 list will match more than one value.  This can be solved by using an
3386 auxiliary dynamic array (on the top of the A stack).  One location for
3387 each @CAF@ indirection is linked to the closure that the @CAF@
3388 references. Once collection is complete this array is traversed and
3389 the corresponding @CAF@ is then updated with the updated pointer from
3390 the auxiliary array.
3391
3392
3393 It is possible to use an alternative marking scheme, using a similar
3394 idea to the copying solution. This scheme avoids the need to update
3395 the @CAF@ references explicitly. We introduce an auxillary {\em mark
3396 and update} @CAF@ info-table which is used to update all @CAF@s at the
3397 start of a collection. The new code marks the @CAF@ reference,
3398 updating it with the returned reference.  The returned reference is
3399 itself returned so the @CAF@ is shorted out.  The code also modifies the
3400 @CAF@ info-table to be a {\em return reference}.  Subsequent attempts to
3401 mark the @CAF@ simply return the updated reference.
3402
3403 A cyclic @CAF@ reference will result in an attempt to mark the @CAF@
3404 before the marking has been completed and the reference updated. We
3405 cannot start marking the @CAF@ as it is already being marked. Nor can
3406 we return the reference as it has not yet been updated. Neither can we
3407 treat the CAF as an indirection since the @CAF@ reference has been
3408 obscured by the pointer reversal stack. All we can do is return the
3409 @CAF@ itself. This will result in some @CAF@ references not being
3410 shorted out.
3411
3412 This scheme has not been adopted but has been implemented. The code is
3413 commented out with @#if 0@.
3414
3415 \subsection{The virtual register set}
3416
3417 We refer to any (atomic) part of the virtual machine state as a ``register.''
3418 These ``registers'' may be shared between all threads in the system or may be
3419 specific to each thread.
3420
3421 Global: 
3422 @
3423   Hp
3424   HpLim
3425   Thread preemption flag
3426 @
3427
3428 Thread specific:
3429 @
3430   TSO - pointer to the TSO for when we have to pack thread away
3431   Sp
3432   SpLim
3433   Su - used to calculate number of arguments on stack
3434      - this is a more convenient representation
3435   Call/return registers (aka General purpose registers)
3436   Cost centre (and other debug/profile info)
3437   Statistic gathering (not in production system)
3438   Exception handlers 
3439     Heap overflow  - possible global?
3440     Stack overflow - possibly global?
3441     Pattern match failure
3442     maybe a failWith handler?
3443     maybe an exitWith handler?
3444     ...
3445 @
3446
3447 Some of these virtual ``registers'' are used very frequently and should
3448 be mapped onto machine registers if at all possible.  Others are used
3449 very infrequently and can be kept in memory to free up registers for
3450 other uses.
3451
3452 On register-poor architectures, we can play a few tricks to reduce the
3453 number of virtual registers which need to be accessed on a regular
3454 basis:
3455
3456 @
3457 - HpLim trick
3458 - Grow stack and heap towards each other (single-threaded system only)
3459 - We might need to keep the C stack pointer in a register if that
3460   is what the OS expects when a signal occurs.
3461 - Preemption flag trick
3462 - If any of the frequently accessed registers cannot be mapped onto
3463   machine registers we should keep the TSO in a machine register to
3464   allow faster access to all the other non-machine registers.
3465 @
3466
3467
3468 \end{document}
3469
3470