Revert "Default to infinite stack size (#8189)"
[ghc.git] / includes / rts / Constants.h
1 /* ----------------------------------------------------------------------------
2 *
3 * (c) The GHC Team, 1998-2009
4 *
5 * Constants
6 *
7 * NOTE: this information is used by both the compiler and the RTS.
8 * Some of it is tweakable, and some of it must be kept up to date
9 * with various other parts of the system.
10 *
11 * Constants which are derived automatically from other definitions in
12 * the system (eg. structure sizes) are generated into the file
13 * DerivedConstants.h by a C program (mkDerivedConstantsHdr).
14 *
15 * To understand the structure of the RTS headers, see the wiki:
16 * http://hackage.haskell.org/trac/ghc/wiki/Commentary/SourceTree/Includes
17 *
18 * -------------------------------------------------------------------------- */
19
20 #ifndef RTS_CONSTANTS_H
21 #define RTS_CONSTANTS_H
22
23 /* -----------------------------------------------------------------------------
24 Minimum closure sizes
25
26 This is the minimum number of words in the payload of a
27 heap-allocated closure, so that the closure has enough room to be
28 overwritten with a forwarding pointer during garbage collection.
29 -------------------------------------------------------------------------- */
30
31 #define MIN_PAYLOAD_SIZE 1
32
33 /* -----------------------------------------------------------------------------
34 Constants to do with specialised closure types.
35 -------------------------------------------------------------------------- */
36
37 /* We have some pre-compiled selector thunks defined in rts/StgStdThunks.hc.
38 * This constant defines the highest selectee index that we can replace with a
39 * reference to the pre-compiled code.
40 */
41
42 #define MAX_SPEC_SELECTEE_SIZE 15
43
44 /* Vector-apply thunks. These thunks just push their free variables
45 * on the stack and enter the first one. They're a bit like PAPs, but
46 * don't have a dynamic size. We've pre-compiled a few to save
47 * space.
48 */
49
50 #define MAX_SPEC_AP_SIZE 7
51
52 /* Specialised FUN/THUNK/CONSTR closure types */
53
54 #define MAX_SPEC_THUNK_SIZE 2
55 #define MAX_SPEC_FUN_SIZE 2
56 #define MAX_SPEC_CONSTR_SIZE 2
57
58 /* Range of built-in table of static small int-like and char-like closures.
59 *
60 * NB. This corresponds with the number of actual INTLIKE/CHARLIKE
61 * closures defined in rts/StgMiscClosures.cmm.
62 */
63 #define MAX_INTLIKE 16
64 #define MIN_INTLIKE (-16)
65
66 #define MAX_CHARLIKE 255
67 #define MIN_CHARLIKE 0
68
69 /* Each byte in the card table for an StgMutaArrPtrs covers
70 * (1<<MUT_ARR_PTRS_CARD_BITS) elements in the array. To find a good
71 * value for this, I used the benchmarks nofib/gc/hash,
72 * nofib/gc/graph, and nofib/gc/gc_bench.
73 */
74 #define MUT_ARR_PTRS_CARD_BITS 7
75
76 /* -----------------------------------------------------------------------------
77 STG Registers.
78
79 Note that in MachRegs.h we define how many of these registers are
80 *real* machine registers, and not just offsets in the Register Table.
81 -------------------------------------------------------------------------- */
82
83 #define MAX_VANILLA_REG 10
84 #define MAX_FLOAT_REG 6
85 #define MAX_DOUBLE_REG 6
86 #define MAX_LONG_REG 1
87 #define MAX_XMM_REG 6
88
89 /* -----------------------------------------------------------------------------
90 Semi-Tagging constants
91
92 Old Comments about this stuff:
93
94 Tags for indirection nodes and ``other'' (probably unevaluated) nodes;
95 normal-form values of algebraic data types will have tags 0, 1, ...
96
97 @INFO_IND_TAG@ is different from @INFO_OTHER_TAG@ just so we can count
98 how often we bang into indirection nodes; that's all. (WDP 95/11)
99
100 ToDo: find out if we need any of this.
101 -------------------------------------------------------------------------- */
102
103 #define INFO_OTHER_TAG (-1)
104 #define INFO_IND_TAG (-2)
105 #define INFO_FIRST_TAG 0
106
107 /* -----------------------------------------------------------------------------
108 How much C stack to reserve for local temporaries when in the STG
109 world. Used in StgCRun.c.
110 -------------------------------------------------------------------------- */
111
112 #define RESERVED_C_STACK_BYTES (2048 * SIZEOF_LONG)
113
114 /* -----------------------------------------------------------------------------
115 How much Haskell stack space to reserve for the saving of registers
116 etc. in the case of a stack/heap overflow.
117
118 This must be large enough to accomodate the largest stack frame
119 pushed in one of the heap check fragments in HeapStackCheck.hc
120 (ie. currently the generic heap checks - 3 words for StgRetDyn,
121 18 words for the saved registers, see StgMacros.h).
122 -------------------------------------------------------------------------- */
123
124 #define RESERVED_STACK_WORDS 21
125
126 /* -----------------------------------------------------------------------------
127 The limit on the size of the stack check performed when we enter an
128 AP_STACK, in words. See raiseAsync() and bug #1466.
129 -------------------------------------------------------------------------- */
130
131 #define AP_STACK_SPLIM 1024
132
133 /* -----------------------------------------------------------------------------
134 Storage manager constants
135 -------------------------------------------------------------------------- */
136
137 /* The size of a block (2^BLOCK_SHIFT bytes) */
138 #define BLOCK_SHIFT 12
139
140 /* The size of a megablock (2^MBLOCK_SHIFT bytes) */
141 #define MBLOCK_SHIFT 20
142
143 /* -----------------------------------------------------------------------------
144 Bitmap/size fields (used in info tables)
145 -------------------------------------------------------------------------- */
146
147 /* In a 32-bit bitmap field, we use 5 bits for the size, and 27 bits
148 * for the bitmap. If the bitmap requires more than 27 bits, then we
149 * store it in a separate array, and leave a pointer in the bitmap
150 * field. On a 64-bit machine, the sizes are extended accordingly.
151 */
152 #if SIZEOF_VOID_P == 4
153 #define BITMAP_SIZE_MASK 0x1f
154 #define BITMAP_BITS_SHIFT 5
155 #elif SIZEOF_VOID_P == 8
156 #define BITMAP_SIZE_MASK 0x3f
157 #define BITMAP_BITS_SHIFT 6
158 #else
159 #error unknown SIZEOF_VOID_P
160 #endif
161
162 /* -----------------------------------------------------------------------------
163 Lag/Drag/Void constants
164 -------------------------------------------------------------------------- */
165
166 /*
167 An LDV word is divided into 3 parts: state bits (LDV_STATE_MASK), creation
168 time bits (LDV_CREATE_MASK), and last use time bits (LDV_LAST_MASK).
169 */
170 #if SIZEOF_VOID_P == 8
171 #define LDV_SHIFT 30
172 #define LDV_STATE_MASK 0x1000000000000000
173 #define LDV_CREATE_MASK 0x0FFFFFFFC0000000
174 #define LDV_LAST_MASK 0x000000003FFFFFFF
175 #define LDV_STATE_CREATE 0x0000000000000000
176 #define LDV_STATE_USE 0x1000000000000000
177 #else
178 #define LDV_SHIFT 15
179 #define LDV_STATE_MASK 0x40000000
180 #define LDV_CREATE_MASK 0x3FFF8000
181 #define LDV_LAST_MASK 0x00007FFF
182 #define LDV_STATE_CREATE 0x00000000
183 #define LDV_STATE_USE 0x40000000
184 #endif /* SIZEOF_VOID_P */
185
186 /* -----------------------------------------------------------------------------
187 TSO related constants
188 -------------------------------------------------------------------------- */
189
190 /*
191 * Constants for the what_next field of a TSO, which indicates how it
192 * is to be run.
193 */
194 #define ThreadRunGHC 1 /* return to address on top of stack */
195 #define ThreadInterpret 2 /* interpret this thread */
196 #define ThreadKilled 3 /* thread has died, don't run it */
197 #define ThreadComplete 4 /* thread has finished */
198
199 /*
200 * Constants for the why_blocked field of a TSO
201 * NB. keep these in sync with GHC/Conc.lhs: threadStatus
202 */
203 #define NotBlocked 0
204 #define BlockedOnMVar 1
205 #define BlockedOnMVarRead 2
206 #define BlockedOnBlackHole 3
207 #define BlockedOnRead 4
208 #define BlockedOnWrite 5
209 #define BlockedOnDelay 6
210 #define BlockedOnSTM 7
211
212 /* Win32 only: */
213 #define BlockedOnDoProc 8
214
215 /* Only relevant for PAR: */
216 /* blocked on a remote closure represented by a Global Address: */
217 #define BlockedOnGA 9
218 /* same as above but without sending a Fetch message */
219 #define BlockedOnGA_NoSend 10
220 /* Only relevant for THREADED_RTS: */
221 #define BlockedOnCCall 11
222 #define BlockedOnCCall_Interruptible 12
223 /* same as above but permit killing the worker thread */
224
225 /* Involved in a message sent to tso->msg_cap */
226 #define BlockedOnMsgThrowTo 13
227
228 /* The thread is not on any run queues, but can be woken up
229 by tryWakeupThread() */
230 #define ThreadMigrating 14
231
232 /*
233 * These constants are returned to the scheduler by a thread that has
234 * stopped for one reason or another. See typedef StgThreadReturnCode
235 * in TSO.h.
236 */
237 #define HeapOverflow 1 /* might also be StackOverflow */
238 #define StackOverflow 2
239 #define ThreadYielding 3
240 #define ThreadBlocked 4
241 #define ThreadFinished 5
242
243 /*
244 * Flags for the tso->flags field.
245 */
246
247 /*
248 * TSO_LOCKED is set when a TSO is locked to a particular Capability.
249 */
250 #define TSO_LOCKED 2
251
252 /*
253 * TSO_BLOCKEX: the TSO is blocking exceptions
254 *
255 * TSO_INTERRUPTIBLE: the TSO can be interrupted if it blocks
256 * interruptibly (eg. with BlockedOnMVar).
257 *
258 * TSO_STOPPED_ON_BREAKPOINT: the thread is currently stopped in a breakpoint
259 */
260 #define TSO_BLOCKEX 4
261 #define TSO_INTERRUPTIBLE 8
262 #define TSO_STOPPED_ON_BREAKPOINT 16
263
264 /*
265 * Used by the sanity checker to check whether TSOs are on the correct
266 * mutable list.
267 */
268 #define TSO_MARKED 64
269
270 /*
271 * Used to communicate between stackSqueeze() and
272 * threadStackOverflow() that a thread's stack was squeezed and the
273 * stack may not need to be expanded.
274 */
275 #define TSO_SQUEEZED 128
276
277 /*
278 * The number of times we spin in a spin lock before yielding (see
279 * #3758). To tune this value, use the benchmark in #3758: run the
280 * server with -N2 and the client both on a dual-core. Also make sure
281 * that the chosen value doesn't slow down any of the parallel
282 * benchmarks in nofib/parallel.
283 */
284 #define SPIN_COUNT 1000
285
286 /* -----------------------------------------------------------------------------
287 Spare workers per Capability in the threaded RTS
288
289 No more than MAX_SPARE_WORKERS will be kept in the thread pool
290 associated with each Capability.
291 -------------------------------------------------------------------------- */
292
293 #define MAX_SPARE_WORKERS 6
294
295 #endif /* RTS_CONSTANTS_H */