1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
|
/* -----------------------------------------------------------------------------
*
* (c) The GHC Team, 1998-2004
*
* Performing updates.
*
* ---------------------------------------------------------------------------*/
#ifndef UPDATES_H
#define UPDATES_H
/* -----------------------------------------------------------------------------
Updates
We have two layers of update macros. The top layer, UPD_IND() and
friends perform all the work of an update. In detail:
- if the closure being updated is a blocking queue, then all the
threads waiting on the blocking queue are updated.
- then the lower level updateWithIndirection() macro is invoked
to actually replace the closure with an indirection (see below).
-------------------------------------------------------------------------- */
#ifdef TICKY_TICKY
# define UPD_IND(updclosure, heapptr) \
UPD_PERM_IND(updclosure,heapptr)
# define UPD_SPEC_IND(updclosure, ind_info, heapptr, and_then) \
UPD_PERM_IND(updclosure,heapptr); and_then
#else
# define SEMI ;
# define UPD_IND(updclosure, heapptr) \
UPD_REAL_IND(updclosure,INFO_PTR(stg_IND_info),heapptr,SEMI)
# define UPD_SPEC_IND(updclosure, ind_info, heapptr, and_then) \
UPD_REAL_IND(updclosure,ind_info,heapptr,and_then)
#endif
/* These macros have to work in both C and C--, so here's the
* impedence matching:
*/
#ifdef CMINUSMINUS
#define BLOCK_BEGIN
#define BLOCK_END
#define DECLARE_IPTR(info) W_ info
#define FCALL foreign "C"
#define INFO_PTR(info) info
#define ARG_PTR "ptr"
#else
#define BLOCK_BEGIN {
#define BLOCK_END }
#define DECLARE_IPTR(info) const StgInfoTable *(info)
#define FCALL /* nothing */
#define INFO_PTR(info) &info
#define StgBlockingQueue_blocking_queue(closure) \
(((StgBlockingQueue *)closure)->blocking_queue)
#define ARG_PTR /* nothing */
#endif
/* UPD_IND actually does a PERM_IND if TICKY_TICKY is on;
if you *really* need an IND use UPD_REAL_IND
*/
#define UPD_REAL_IND(updclosure, ind_info, heapptr, and_then) \
BLOCK_BEGIN \
DECLARE_IPTR(info); \
info = GET_INFO(updclosure); \
updateWithIndirection(ind_info, \
updclosure, \
heapptr, \
and_then); \
BLOCK_END
#if defined(PROFILING) || defined(TICKY_TICKY)
#define UPD_PERM_IND(updclosure, heapptr) \
BLOCK_BEGIN \
updateWithPermIndirection(updclosure, \
heapptr); \
BLOCK_END
#endif
#if defined(RTS_SUPPORTS_THREADS)
# ifdef TICKY_TICKY
# define UPD_IND_NOLOCK(updclosure, heapptr) \
BLOCK_BEGIN \
updateWithPermIndirection(updclosure, \
heapptr); \
BLOCK_END
# else
# define UPD_IND_NOLOCK(updclosure, heapptr) \
BLOCK_BEGIN \
updateWithIndirection(INFO_PTR(stg_IND_info), \
updclosure, \
heapptr,); \
BLOCK_END
# endif
#else
#define UPD_IND_NOLOCK(updclosure,heapptr) UPD_IND(updclosure,heapptr)
#endif
/* -----------------------------------------------------------------------------
Awaken any threads waiting on a blocking queue (BLACKHOLE_BQ).
-------------------------------------------------------------------------- */
#if defined(PAR)
/*
In a parallel setup several types of closures might have a blocking queue:
BLACKHOLE_BQ ... same as in the default concurrent setup; it will be
reawakened via calling UPD_IND on that closure after
having finished the computation of the graph
FETCH_ME_BQ ... a global indirection (FETCH_ME) may be entered by a
local TSO, turning it into a FETCH_ME_BQ; it will be
reawakened via calling processResume
RBH ... a revertible black hole may be entered by another
local TSO, putting it onto its blocking queue; since
RBHs only exist while the corresponding closure is in
transit, they will be reawakened via calling
convertToFetchMe (upon processing an ACK message)
In a parallel setup a blocking queue may contain 3 types of closures:
TSO ... as in the default concurrent setup
BLOCKED_FETCH ... indicating that a TSO on another PE is waiting for
the result of the current computation
CONSTR ... an RBHSave closure (which contains data ripped out of
the closure to make room for a blocking queue; since
it only contains data we use the exisiting type of
a CONSTR closure); this closure is the end of a
blocking queue for an RBH closure; it only exists in
this kind of blocking queue and must be at the end
of the queue
*/
extern void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
#define DO_AWAKEN_BQ(bqe, node) STGCALL2(awakenBlockedQueue, bqe, node);
#define AWAKEN_BQ(info,closure) \
if (info == &stg_BLACKHOLE_BQ_info || \
info == &stg_FETCH_ME_BQ_info || \
get_itbl(closure)->type == RBH) { \
DO_AWAKEN_BQ(((StgBlockingQueue *)closure)->blocking_queue, closure); \
}
#elif defined(GRAN)
extern void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
#define DO_AWAKEN_BQ(bq, node) STGCALL2(awakenBlockedQueue, bq, node);
/* In GranSim we don't have FETCH_ME or FETCH_ME_BQ closures, so they are
not checked. The rest of the code is the same as for GUM.
*/
#define AWAKEN_BQ(info,closure) \
if (info == &stg_BLACKHOLE_BQ_info || \
get_itbl(closure)->type == RBH) { \
DO_AWAKEN_BQ(((StgBlockingQueue *)closure)->blocking_queue, closure); \
}
#endif /* GRAN || PAR */
/* -----------------------------------------------------------------------------
Updates: lower-level macros which update a closure with an
indirection to another closure.
There are several variants of this code.
PROFILING:
-------------------------------------------------------------------------- */
/* LDV profiling:
* We call LDV_recordDead_FILL_SLOP_DYNAMIC(p1) regardless of the generation in
* which p1 resides.
*
* Note:
* After all, we do *NOT* need to call LDV_RECORD_CREATE() for both IND and
* IND_OLDGEN closures because they are inherently used. But, it corrupts
* the invariants that every closure keeps its creation time in the profiling
* field. So, we call LDV_RECORD_CREATE().
*/
/* In the DEBUG case, we also zero out the slop of the old closure,
* so that the sanity checker can tell where the next closure is.
*
* Two important invariants: we should never try to update a closure
* to point to itself, and the closure being updated should not
* already have been updated (the mutable list will get messed up
* otherwise).
*
* NB. We do *not* do this in THREADED_RTS mode, because when we have the
* possibility of multiple threads entering the same closure, zeroing
* the slop in one of the threads would have a disastrous effect on
* the other (seen in the wild!).
*/
#ifdef CMINUSMINUS
#define FILL_SLOP(p) \
W_ inf; \
W_ sz; \
W_ i; \
inf = %GET_STD_INFO(p); \
if (%INFO_TYPE(inf) != HALF_W_(THUNK_SELECTOR) \
&& %INFO_TYPE(inf) != HALF_W_(BLACKHOLE) \
&& %INFO_TYPE(inf) != HALF_W_(CAF_BLACKHOLE)) { \
if (%INFO_TYPE(inf) == HALF_W_(AP_STACK)) { \
sz = StgAP_STACK_size(p) + BYTES_TO_WDS(SIZEOF_StgAP_STACK_NoThunkHdr); \
} else { \
if (%INFO_TYPE(inf) == HALF_W_(AP)) { \
sz = TO_W_(StgAP_n_args(p)) + BYTES_TO_WDS(SIZEOF_StgAP_NoThunkHdr); \
} else { \
sz = TO_W_(%INFO_PTRS(inf)) + TO_W_(%INFO_NPTRS(inf)); \
} \
} \
i = 0; \
for: \
if (i < sz) { \
StgThunk_payload(p,i) = 0; \
i = i + 1; \
goto for; \
} \
}
#else /* !CMINUSMINUS */
INLINE_HEADER void
FILL_SLOP(StgClosure *p)
{
StgInfoTable *inf = get_itbl(p);
nat i, sz;
switch (inf->type) {
case BLACKHOLE:
case CAF_BLACKHOLE:
case THUNK_SELECTOR:
return;
case AP:
sz = ((StgAP *)p)->n_args + sizeofW(StgAP) - sizeofW(StgThunkHeader);
break;
case AP_STACK:
sz = ((StgAP_STACK *)p)->size + sizeofW(StgAP_STACK) - sizeofW(StgThunkHeader);
break;
default:
sz = inf->layout.payload.ptrs + inf->layout.payload.nptrs;
break;
}
for (i = 0; i < sz; i++) {
((StgThunk *)p)->payload[i] = 0;
}
}
#endif /* CMINUSMINUS */
#if !defined(DEBUG) || defined(THREADED_RTS)
#define DEBUG_FILL_SLOP(p) /* do nothing */
#else
#define DEBUG_FILL_SLOP(p) FILL_SLOP(p)
#endif
/* We have two versions of this macro (sadly), one for use in C-- code,
* and the other for C.
*
* The and_then argument is a performance hack so that we can paste in
* the continuation code directly. It helps shave a couple of
* instructions off the common case in the update code, which is
* worthwhile (the update code is often part of the inner loop).
* (except that gcc now appears to common up this code again and
* invert the optimisation. Grrrr --SDM).
*/
#ifdef CMINUSMINUS
#define generation(n) (W_[generations] + n*SIZEOF_generation)
#define updateWithIndirection(ind_info, p1, p2, and_then) \
W_ bd; \
\
DEBUG_FILL_SLOP(p1); \
LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1); \
StgInd_indirectee(p1) = p2; \
foreign "C" wb() []; \
bd = Bdescr(p1); \
if (bdescr_gen_no(bd) != 0 :: CInt) { \
foreign "C" recordMutableCap(p1 "ptr", \
MyCapability() "ptr", \
bdescr_gen_no(bd)) [R1]; \
SET_INFO(p1, stg_IND_OLDGEN_info); \
LDV_RECORD_CREATE(p1); \
TICK_UPD_OLD_IND(); \
and_then; \
} else { \
SET_INFO(p1, ind_info); \
LDV_RECORD_CREATE(p1); \
TICK_UPD_NEW_IND(); \
and_then; \
}
#else
#define updateWithIndirection(ind_info, p1, p2, and_then) \
{ \
bdescr *bd; \
\
/* cas(p1, 0, &stg_WHITEHOLE_info); */ \
ASSERT( (P_)p1 != (P_)p2 && !closure_IND(p1) ); \
DEBUG_FILL_SLOP(p1); \
LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1); \
((StgInd *)p1)->indirectee = p2; \
wb(); \
bd = Bdescr((P_)p1); \
if (bd->gen_no != 0) { \
recordMutableGenLock(p1, &generations[bd->gen_no]); \
SET_INFO(p1, &stg_IND_OLDGEN_info); \
TICK_UPD_OLD_IND(); \
and_then; \
} else { \
SET_INFO(p1, ind_info); \
LDV_RECORD_CREATE(p1); \
TICK_UPD_NEW_IND(); \
and_then; \
} \
}
#endif
/* The permanent indirection version isn't performance critical. We
* therefore use an inline C function instead of the C-- macro.
*/
#ifndef CMINUSMINUS
INLINE_HEADER void
updateWithPermIndirection(StgClosure *p1,
StgClosure *p2)
{
bdescr *bd;
ASSERT( p1 != p2 && !closure_IND(p1) );
/*
* @LDV profiling
* Destroy the old closure.
* Nb: LDV_* stuff cannot mix with ticky-ticky
*/
LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);
bd = Bdescr((P_)p1);
if (bd->gen_no != 0) {
recordMutableGenLock(p1, &generations[bd->gen_no]);
((StgInd *)p1)->indirectee = p2;
SET_INFO(p1, &stg_IND_OLDGEN_PERM_info);
/*
* @LDV profiling
* We have just created a new closure.
*/
LDV_RECORD_CREATE(p1);
TICK_UPD_OLD_PERM_IND();
} else {
((StgInd *)p1)->indirectee = p2;
SET_INFO(p1, &stg_IND_PERM_info);
/*
* @LDV profiling
* We have just created a new closure.
*/
LDV_RECORD_CREATE(p1);
TICK_UPD_NEW_PERM_IND(p1);
}
}
#endif
#endif /* UPDATES_H */
|
