/[jscoverage]/trunk/js/jsgc.h
ViewVC logotype

Contents of /trunk/js/jsgc.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 507 - (show annotations)
Sun Jan 10 07:23:34 2010 UTC (9 years, 10 months ago) by siliconforks
File MIME type: text/plain
File size: 13715 byte(s)
Update SpiderMonkey from Firefox 3.6rc1.

1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 *
3 * ***** BEGIN LICENSE BLOCK *****
4 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5 *
6 * The contents of this file are subject to the Mozilla Public License Version
7 * 1.1 (the "License"); you may not use this file except in compliance with
8 * the License. You may obtain a copy of the License at
9 * http://www.mozilla.org/MPL/
10 *
11 * Software distributed under the License is distributed on an "AS IS" basis,
12 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13 * for the specific language governing rights and limitations under the
14 * License.
15 *
16 * The Original Code is Mozilla Communicator client code, released
17 * March 31, 1998.
18 *
19 * The Initial Developer of the Original Code is
20 * Netscape Communications Corporation.
21 * Portions created by the Initial Developer are Copyright (C) 1998
22 * the Initial Developer. All Rights Reserved.
23 *
24 * Contributor(s):
25 *
26 * Alternatively, the contents of this file may be used under the terms of
27 * either of the GNU General Public License Version 2 or later (the "GPL"),
28 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
29 * in which case the provisions of the GPL or the LGPL are applicable instead
30 * of those above. If you wish to allow use of your version of this file only
31 * under the terms of either the GPL or the LGPL, and not to allow others to
32 * use your version of this file under the terms of the MPL, indicate your
33 * decision by deleting the provisions above and replace them with the notice
34 * and other provisions required by the GPL or the LGPL. If you do not delete
35 * the provisions above, a recipient may use your version of this file under
36 * the terms of any one of the MPL, the GPL or the LGPL.
37 *
38 * ***** END LICENSE BLOCK ***** */
39
40 #ifndef jsgc_h___
41 #define jsgc_h___
42 /*
43 * JS Garbage Collector.
44 */
45 #include "jsprvtd.h"
46 #include "jspubtd.h"
47 #include "jsdhash.h"
48 #include "jsbit.h"
49 #include "jsutil.h"
50 #include "jstask.h"
51
52 JS_BEGIN_EXTERN_C
53
54 #define JSTRACE_XML 3
55
56 /*
57 * One past the maximum trace kind.
58 */
59 #define JSTRACE_LIMIT 4
60
61 /*
62 * We use the trace kinds as the types for all GC things except external
63 * strings.
64 */
65 #define GCX_OBJECT JSTRACE_OBJECT /* JSObject */
66 #define GCX_DOUBLE JSTRACE_DOUBLE /* jsdouble */
67 #define GCX_STRING JSTRACE_STRING /* JSString */
68 #define GCX_XML JSTRACE_XML /* JSXML */
69 #define GCX_EXTERNAL_STRING JSTRACE_LIMIT /* JSString with external
70 chars */
71 /*
72 * The number of defined GC types and the maximum limit for the number of
73 * possible GC types.
74 */
75 #define GCX_NTYPES (GCX_EXTERNAL_STRING + 8)
76 #define GCX_LIMIT_LOG2 4 /* type index bits */
77 #define GCX_LIMIT JS_BIT(GCX_LIMIT_LOG2)
78
79 /* GC flag definitions, must fit in 8 bits (type index goes in the low bits). */
80 #define GCF_TYPEMASK JS_BITMASK(GCX_LIMIT_LOG2)
81 #define GCF_MARK JS_BIT(GCX_LIMIT_LOG2)
82 #define GCF_FINAL JS_BIT(GCX_LIMIT_LOG2 + 1)
83 #define GCF_LOCKSHIFT (GCX_LIMIT_LOG2 + 2) /* lock bit shift */
84 #define GCF_LOCK JS_BIT(GCF_LOCKSHIFT) /* lock request bit in API */
85
86 /*
87 * Get the type of the external string or -1 if the string was not created
88 * with JS_NewExternalString.
89 */
90 extern intN
91 js_GetExternalStringGCType(JSString *str);
92
93 extern JS_FRIEND_API(uint32)
94 js_GetGCThingTraceKind(void *thing);
95
96 /*
97 * The sole purpose of the function is to preserve public API compatibility
98 * in JS_GetStringBytes which takes only single JSString* argument.
99 */
100 JSRuntime*
101 js_GetGCStringRuntime(JSString *str);
102
103 #if 1
104 /*
105 * Since we're forcing a GC from JS_GC anyway, don't bother wasting cycles
106 * loading oldval. XXX remove implied force, fix jsinterp.c's "second arg
107 * ignored", etc.
108 */
109 #define GC_POKE(cx, oldval) ((cx)->runtime->gcPoke = JS_TRUE)
110 #else
111 #define GC_POKE(cx, oldval) ((cx)->runtime->gcPoke = JSVAL_IS_GCTHING(oldval))
112 #endif
113
114 extern JSBool
115 js_InitGC(JSRuntime *rt, uint32 maxbytes);
116
117 extern void
118 js_FinishGC(JSRuntime *rt);
119
120 extern intN
121 js_ChangeExternalStringFinalizer(JSStringFinalizeOp oldop,
122 JSStringFinalizeOp newop);
123
124 extern JSBool
125 js_AddRoot(JSContext *cx, void *rp, const char *name);
126
127 extern JSBool
128 js_AddRootRT(JSRuntime *rt, void *rp, const char *name);
129
130 extern JSBool
131 js_RemoveRoot(JSRuntime *rt, void *rp);
132
133 #ifdef DEBUG
134 extern void
135 js_DumpNamedRoots(JSRuntime *rt,
136 void (*dump)(const char *name, void *rp, void *data),
137 void *data);
138 #endif
139
140 extern uint32
141 js_MapGCRoots(JSRuntime *rt, JSGCRootMapFun map, void *data);
142
143 /* Table of pointers with count valid members. */
144 typedef struct JSPtrTable {
145 size_t count;
146 void **array;
147 } JSPtrTable;
148
149 extern JSBool
150 js_RegisterCloseableIterator(JSContext *cx, JSObject *obj);
151
152 /*
153 * The private JSGCThing struct, which describes a gcFreeList element.
154 */
155 struct JSGCThing {
156 JSGCThing *next;
157 uint8 *flagp;
158 };
159
160 #define GC_NBYTES_MAX (10 * sizeof(JSGCThing))
161 #define GC_NUM_FREELISTS (GC_NBYTES_MAX / sizeof(JSGCThing))
162 #define GC_FREELIST_NBYTES(i) (((i) + 1) * sizeof(JSGCThing))
163 #define GC_FREELIST_INDEX(n) (((n) / sizeof(JSGCThing)) - 1)
164
165 /*
166 * Allocates a new GC thing of the given size. After a successful allocation
167 * the caller must fully initialize the thing before calling any function that
168 * can potentially trigger GC. This will ensure that GC tracing never sees junk
169 * values stored in the partially initialized thing.
170 */
171 extern JSObject*
172 js_NewGCObject(JSContext *cx, uintN flags);
173
174 extern JSString*
175 js_NewGCString(JSContext *cx, uintN flags);
176
177 extern JSFunction*
178 js_NewGCFunction(JSContext *cx, uintN flags);
179
180 extern JSXML*
181 js_NewGCXML(JSContext *cx, uintN flags);
182
183 /*
184 * Allocate a new double jsval and store the result in *vp. vp must be a root.
185 * The function does not copy the result into any weak root.
186 */
187 extern JSBool
188 js_NewDoubleInRootedValue(JSContext *cx, jsdouble d, jsval *vp);
189
190 /*
191 * Return a pointer to a new GC-allocated and weakly-rooted jsdouble number,
192 * or null when the allocation fails.
193 */
194 extern jsdouble *
195 js_NewWeaklyRootedDouble(JSContext *cx, jsdouble d);
196
197 #ifdef JS_TRACER
198 extern JSBool
199 js_ReserveObjects(JSContext *cx, size_t nobjects);
200 #endif
201
202 extern JSBool
203 js_LockGCThingRT(JSRuntime *rt, void *thing);
204
205 extern JSBool
206 js_UnlockGCThingRT(JSRuntime *rt, void *thing);
207
208 extern JSBool
209 js_IsAboutToBeFinalized(JSContext *cx, void *thing);
210
211 /*
212 * Macro to test if a traversal is the marking phase of GC to avoid exposing
213 * ScriptFilenameEntry to traversal implementations.
214 */
215 #define IS_GC_MARKING_TRACER(trc) ((trc)->callback == NULL)
216
217 #if JS_HAS_XML_SUPPORT
218 # define JS_IS_VALID_TRACE_KIND(kind) ((uint32)(kind) < JSTRACE_LIMIT)
219 #else
220 # define JS_IS_VALID_TRACE_KIND(kind) ((uint32)(kind) <= JSTRACE_STRING)
221 #endif
222
223 /*
224 * Trace jsval when JSVAL_IS_OBJECT(v) can be a GC thing pointer tagged as a
225 * jsval. NB: punning an arbitrary JSString * as an untagged (object-tagged)
226 * jsval no longer works due to static int and unit strings!
227 */
228 extern void
229 js_CallValueTracerIfGCThing(JSTracer *trc, jsval v);
230
231 extern void
232 js_TraceStackFrame(JSTracer *trc, JSStackFrame *fp);
233
234 extern JS_REQUIRES_STACK void
235 js_TraceRuntime(JSTracer *trc, JSBool allAtoms);
236
237 extern JS_REQUIRES_STACK JS_FRIEND_API(void)
238 js_TraceContext(JSTracer *trc, JSContext *acx);
239
240 /*
241 * Schedule the GC call at a later safe point.
242 */
243 #ifndef JS_THREADSAFE
244 # define js_TriggerGC(cx, gcLocked) js_TriggerGC (cx)
245 #endif
246
247 extern void
248 js_TriggerGC(JSContext *cx, JSBool gcLocked);
249
250 /*
251 * Kinds of js_GC invocation.
252 */
253 typedef enum JSGCInvocationKind {
254 /* Normal invocation. */
255 GC_NORMAL = 0,
256
257 /*
258 * Called from js_DestroyContext for last JSContext in a JSRuntime, when
259 * it is imperative that rt->gcPoke gets cleared early in js_GC.
260 */
261 GC_LAST_CONTEXT = 1,
262
263 /*
264 * Flag bit telling js_GC that the caller has already acquired rt->gcLock.
265 * Currently, this flag is set for the invocation kinds that also preserve
266 * atoms and weak roots, so we don't need another bit for GC_KEEP_ATOMS.
267 */
268 GC_LOCK_HELD = 0x10,
269 GC_KEEP_ATOMS = GC_LOCK_HELD,
270
271 /*
272 * Called from js_SetProtoOrParent with a request to set an object's proto
273 * or parent slot inserted on rt->setSlotRequests.
274 */
275 GC_SET_SLOT_REQUEST = GC_LOCK_HELD | 1,
276
277 /*
278 * Called from js_NewGCThing as a last-ditch GC attempt. See comments in
279 * jsgc.c just before js_GC's definition for details.
280 */
281 GC_LAST_DITCH = GC_LOCK_HELD | 2
282 } JSGCInvocationKind;
283
284 extern void
285 js_GC(JSContext *cx, JSGCInvocationKind gckind);
286
287 typedef struct JSGCArenaInfo JSGCArenaInfo;
288 typedef struct JSGCArenaList JSGCArenaList;
289 typedef struct JSGCChunkInfo JSGCChunkInfo;
290
291 struct JSGCArenaList {
292 JSGCArenaInfo *last; /* last allocated GC arena */
293 uint32 lastCount; /* number of allocated things in the last
294 arena */
295 uint32 thingSize; /* size of things to allocate on this list
296 */
297 JSGCThing *freeList; /* list of free GC things */
298 };
299
300 typedef union JSGCDoubleCell JSGCDoubleCell;
301
302 union JSGCDoubleCell {
303 double number;
304 JSGCDoubleCell *link;
305 };
306
307 typedef struct JSGCDoubleArenaList {
308 JSGCArenaInfo *first; /* first allocated GC arena */
309 jsbitmap *nextDoubleFlags; /* bitmask with flags to check for free
310 things */
311 } JSGCDoubleArenaList;
312
313 extern void
314 js_DestroyScriptsToGC(JSContext *cx, JSThreadData *data);
315
316 struct JSWeakRoots {
317 /* Most recently created things by type, members of the GC's root set. */
318 void *newborn[GCX_NTYPES];
319
320 /* Atom root for the last-looked-up atom on this context. */
321 jsval lastAtom;
322
323 /* Root for the result of the most recent js_InternalInvoke call. */
324 jsval lastInternalResult;
325 };
326
327 #define JS_CLEAR_WEAK_ROOTS(wr) (memset((wr), 0, sizeof(JSWeakRoots)))
328
329 #ifdef __cplusplus /* Allow inclusion from LiveConnect C files. */
330 #ifdef JS_THREADSAFE
331 class JSFreePointerListTask : public JSBackgroundTask {
332 void *head;
333 public:
334 JSFreePointerListTask() : head(NULL) {}
335
336 void add(void* ptr) {
337 *(void**)ptr = head;
338 head = ptr;
339 }
340
341 void run() {
342 void *ptr = head;
343 while (ptr) {
344 void *next = *(void **)ptr;
345 js_free(ptr);
346 ptr = next;
347 }
348 }
349 };
350 #endif
351 #endif /* __cplusplus */
352
353 /*
354 * Free the chars held by str when it is finalized by the GC. When type is
355 * less then zero, it denotes an internal string. Otherwise it denotes the
356 * type of the external string allocated with JS_NewExternalString.
357 *
358 * This function always needs rt but can live with null cx.
359 */
360 extern void
361 js_FinalizeStringRT(JSRuntime *rt, JSString *str, intN type, JSContext *cx);
362
363 #ifdef DEBUG_notme
364 #define JS_GCMETER 1
365 #endif
366
367 #ifdef JS_GCMETER
368
369 typedef struct JSGCArenaStats {
370 uint32 alloc; /* allocation attempts */
371 uint32 localalloc; /* allocations from local lists */
372 uint32 retry; /* allocation retries after running the GC */
373 uint32 fail; /* allocation failures */
374 uint32 nthings; /* live GC things */
375 uint32 maxthings; /* maximum of live GC cells */
376 double totalthings; /* live GC things the GC scanned so far */
377 uint32 narenas; /* number of arena in list before the GC */
378 uint32 newarenas; /* new arenas allocated before the last GC */
379 uint32 livearenas; /* number of live arenas after the last GC */
380 uint32 maxarenas; /* maximum of allocated arenas */
381 uint32 totalarenas; /* total number of arenas with live things that
382 GC scanned so far */
383 } JSGCArenaStats;
384
385 typedef struct JSGCStats {
386 uint32 finalfail; /* finalizer calls allocator failures */
387 uint32 lockborn; /* things born locked */
388 uint32 lock; /* valid lock calls */
389 uint32 unlock; /* valid unlock calls */
390 uint32 depth; /* mark tail recursion depth */
391 uint32 maxdepth; /* maximum mark tail recursion depth */
392 uint32 cdepth; /* mark recursion depth of C functions */
393 uint32 maxcdepth; /* maximum mark recursion depth of C functions */
394 uint32 untraced; /* number of times tracing of GC thing's children were
395 delayed due to a low C stack */
396 #ifdef DEBUG
397 uint32 maxuntraced;/* maximum number of things with children to trace
398 later */
399 #endif
400 uint32 maxlevel; /* maximum GC nesting (indirect recursion) level */
401 uint32 poke; /* number of potentially useful GC calls */
402 uint32 afree; /* thing arenas freed so far */
403 uint32 stackseg; /* total extraordinary stack segments scanned */
404 uint32 segslots; /* total stack segment jsval slots scanned */
405 uint32 nclose; /* number of objects with close hooks */
406 uint32 maxnclose; /* max number of objects with close hooks */
407 uint32 closelater; /* number of close hooks scheduled to run */
408 uint32 maxcloselater; /* max number of close hooks scheduled to run */
409
410 JSGCArenaStats arenaStats[GC_NUM_FREELISTS];
411 JSGCArenaStats doubleArenaStats;
412 } JSGCStats;
413
414 extern JS_FRIEND_API(void)
415 js_DumpGCStats(JSRuntime *rt, FILE *fp);
416
417 #endif /* JS_GCMETER */
418
419 JS_END_EXTERN_C
420
421 #endif /* jsgc_h___ */

  ViewVC Help
Powered by ViewVC 1.1.24