[project @ 2003-08-01 15:38:41 by panne]
[ghc-hetmet.git] / ghc / includes / StgStorage.h
1 /* -----------------------------------------------------------------------------
2  * $Id: StgStorage.h,v 1.12 2003/03/26 17:40:58 sof Exp $
3  *
4  * (c) The GHC Team, 1998-1999
5  *
6  * STG Storage Manager Interface
7  *
8  * ---------------------------------------------------------------------------*/
9
10 #ifndef STGSTORAGE_H
11 #define STGSTORAGE_H
12
13 /* GENERATION GC NOTES
14  *
15  * We support an arbitrary number of generations, with an arbitrary number
16  * of steps per generation.  Notes (in no particular order):
17  *
18  *       - all generations except the oldest should have two steps.  This gives
19  *         objects a decent chance to age before being promoted, and in
20  *         particular will ensure that we don't end up with too many
21  *         thunks being updated in older generations.
22  *
23  *       - the oldest generation has one step.  There's no point in aging
24  *         objects in the oldest generation.
25  *
26  *       - generation 0, step 0 (G0S0) is the allocation area.  It is given
27  *         a fixed set of blocks during initialisation, and these blocks
28  *         are never freed.
29  *
30  *       - during garbage collection, each step which is an evacuation
31  *         destination (i.e. all steps except G0S0) is allocated a to-space.
32  *         evacuated objects are allocated into the step's to-space until
33  *         GC is finished, when the original step's contents may be freed
34  *         and replaced by the to-space.
35  *
36  *       - the mutable-list is per-generation (not per-step).  G0 doesn't 
37  *         have one (since every garbage collection collects at least G0).
38  * 
39  *       - block descriptors contain pointers to both the step and the
40  *         generation that the block belongs to, for convenience.
41  *
42  *       - static objects are stored in per-generation lists.  See GC.c for
43  *         details of how we collect CAFs in the generational scheme.
44  *
45  *       - large objects are per-step, and are promoted in the same way
46  *         as small objects, except that we may allocate large objects into
47  *         generation 1 initially.
48  */
49
50 typedef struct _step {
51   unsigned int         no;              /* step number */
52   bdescr *             blocks;          /* blocks in this step */
53   unsigned int         n_blocks;        /* number of blocks */
54   struct _step *       to;              /* destination step for live objects */
55   struct _generation * gen;             /* generation this step belongs to */
56   unsigned int         gen_no;          /* generation number (cached) */
57   bdescr *             large_objects;   /* large objects (doubly linked) */
58   unsigned int         n_large_blocks;  /* no. of blocks used by large objs */
59   int                  is_compacted;    /* compact this step? (old gen only) */
60
61   /* temporary use during GC: */
62   StgPtr       hp;                      /* next free locn in to-space */
63   StgPtr       hpLim;                   /* end of current to-space block */
64   bdescr *     hp_bd;                   /* bdescr of current to-space block */
65   bdescr *     to_blocks;               /* bdescr of first to-space block */
66   unsigned int n_to_blocks;             /* number of blocks in to-space */
67   bdescr *     scan_bd;                 /* block currently being scanned */
68   StgPtr       scan;                    /* scan pointer in current block */
69   bdescr *     new_large_objects;       /* large objects collected so far */
70   bdescr *     scavenged_large_objects; /* live large objs after GC (d-link) */
71   unsigned int n_scavenged_large_blocks;/* size of above */
72   bdescr *     bitmap;                  /* bitmap for compacting collection */
73 } step;
74
75 typedef struct _generation {
76   unsigned int   no;                    /* generation number */
77   step *         steps;                 /* steps */
78   unsigned int   n_steps;               /* number of steps */
79   unsigned int   max_blocks;            /* max blocks in step 0 */
80   StgMutClosure *mut_list;              /* mut objects in this gen (not G0)*/
81   StgMutClosure *mut_once_list;         /* objects that point to younger gens */
82
83   /* temporary use during GC: */
84   StgMutClosure * saved_mut_list;
85
86   /* stats information */
87   unsigned int collections;
88   unsigned int failed_promotions;
89 } generation;
90
91 /* -----------------------------------------------------------------------------
92    Allocation area for compiled code
93
94    OpenNursery(hp,hplim)        Opens the allocation area, and sets hp
95                                 and hplim appropriately.
96
97    CloseNursery(hp)             Closes the allocation area.
98
99    -------------------------------------------------------------------------- */
100
101 #define OpenNursery(hp,hplim)                           \
102   (hp    = CurrentNursery->free-1,                      \
103    hplim = CurrentNursery->start + CurrentNursery->blocks*BLOCK_SIZE_W - 1)
104   
105 #define CloseNursery(hp)  (CurrentNursery->free = (P_)(hp)+1)
106
107 /* -----------------------------------------------------------------------------
108    Prototype for an evacuate-like function
109    -------------------------------------------------------------------------- */
110
111 typedef void (*evac_fn)(StgClosure **);
112
113 /* -----------------------------------------------------------------------------
114    Trigger a GC from Haskell land.
115    -------------------------------------------------------------------------- */
116
117 extern void performGC(void);
118 extern void performMajorGC(void);
119 extern void performGCWithRoots(void (*get_roots)(evac_fn));
120
121 #endif /* STGSTORAGE_H */