![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jsgc.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / include / mozilla / js|
Return to jsgc.h CVS log | Up to [Synchronet] / sbbs / include / mozilla / js |
1.1 root 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:
49: JS_BEGIN_EXTERN_C
50:
51: /* GC thing type indexes. */
52: #define GCX_OBJECT 0 /* JSObject */
53: #define GCX_STRING 1 /* JSString */
54: #define GCX_DOUBLE 2 /* jsdouble */
55: #define GCX_MUTABLE_STRING 3 /* JSString that's mutable --
56: single-threaded only! */
57: #define GCX_EXTERNAL_STRING 4 /* JSString w/ external chars */
58: #define GCX_NTYPES_LOG2 3 /* type index bits */
59: #define GCX_NTYPES JS_BIT(GCX_NTYPES_LOG2)
60:
61: /* GC flag definitions, must fit in 8 bits (type index goes in the low bits). */
62: #define GCF_TYPEMASK JS_BITMASK(GCX_NTYPES_LOG2)
63: #define GCF_MARK JS_BIT(GCX_NTYPES_LOG2)
64: #define GCF_FINAL JS_BIT(GCX_NTYPES_LOG2 + 1)
65: #define GCF_LOCKSHIFT (GCX_NTYPES_LOG2 + 2) /* lock bit shift and mask */
66: #define GCF_LOCKMASK (JS_BITMASK(8 - GCF_LOCKSHIFT) << GCF_LOCKSHIFT)
67: #define GCF_LOCK JS_BIT(GCF_LOCKSHIFT) /* lock request bit in API */
68:
69: /* Pseudo-flag that modifies GCX_STRING to make GCX_MUTABLE_STRING. */
70: #define GCF_MUTABLE 2
71:
72: #if (GCX_STRING | GCF_MUTABLE) != GCX_MUTABLE_STRING
73: # error "mutable string type index botch!"
74: #endif
75:
76: extern uint8 *
77: js_GetGCThingFlags(void *thing);
78:
79: /* These are compatible with JSDHashEntryStub. */
80: struct JSGCRootHashEntry {
81: JSDHashEntryHdr hdr;
82: void *root;
83: const char *name;
84: };
85:
86: struct JSGCLockHashEntry {
87: JSDHashEntryHdr hdr;
88: const JSGCThing *thing;
89: uint32 count;
90: };
91:
92: #if 1
93: /*
94: * Since we're forcing a GC from JS_GC anyway, don't bother wasting cycles
95: * loading oldval. XXX remove implied force, fix jsinterp.c's "second arg
96: * ignored", etc.
97: */
98: #define GC_POKE(cx, oldval) ((cx)->runtime->gcPoke = JS_TRUE)
99: #else
100: #define GC_POKE(cx, oldval) ((cx)->runtime->gcPoke = JSVAL_IS_GCTHING(oldval))
101: #endif
102:
103: extern intN
104: js_ChangeExternalStringFinalizer(JSStringFinalizeOp oldop,
105: JSStringFinalizeOp newop);
106:
107: extern JSBool
108: js_InitGC(JSRuntime *rt, uint32 maxbytes);
109:
110: extern void
111: js_FinishGC(JSRuntime *rt);
112:
113: extern JSBool
114: js_AddRoot(JSContext *cx, void *rp, const char *name);
115:
116: extern JSBool
117: js_AddRootRT(JSRuntime *rt, void *rp, const char *name);
118:
119: extern JSBool
120: js_RemoveRoot(JSRuntime *rt, void *rp);
121:
122: extern void *
123: js_AllocGCThing(JSContext *cx, uintN flags);
124:
125: extern JSBool
126: js_LockGCThing(JSContext *cx, void *thing);
127:
128: extern JSBool
129: js_LockGCThingRT(JSRuntime *rt, void *thing);
130:
131: extern JSBool
132: js_UnlockGCThingRT(JSRuntime *rt, void *thing);
133:
134: extern JSBool
135: js_IsAboutToBeFinalized(JSContext *cx, void *thing);
136:
137: extern void
138: js_MarkAtom(JSContext *cx, JSAtom *atom, void *arg);
139:
140: /* We avoid a large number of unnecessary calls by doing the flag check first */
141: #define GC_MARK_ATOM(cx, atom, arg) \
142: JS_BEGIN_MACRO \
143: if (!((atom)->flags & ATOM_MARK)) \
144: js_MarkAtom(cx, atom, arg); \
145: JS_END_MACRO
146:
147: extern void
148: js_MarkGCThing(JSContext *cx, void *thing, void *arg);
149:
150: #ifdef GC_MARK_DEBUG
151:
152: typedef struct GCMarkNode GCMarkNode;
153:
154: struct GCMarkNode {
155: void *thing;
156: const char *name;
157: GCMarkNode *next;
158: GCMarkNode *prev;
159: };
160:
161: #define GC_MARK(cx_, thing_, name_, prev_) \
162: JS_BEGIN_MACRO \
163: GCMarkNode node_; \
164: node_.thing = thing_; \
165: node_.name = name_; \
166: node_.next = NULL; \
167: node_.prev = prev_; \
168: if (prev_) ((GCMarkNode *)(prev_))->next = &node_; \
169: js_MarkGCThing(cx_, thing_, &node_); \
170: JS_END_MACRO
171:
172: #else /* !GC_MARK_DEBUG */
173:
174: #define GC_MARK(cx, thing, name, prev) js_MarkGCThing(cx, thing, NULL)
175:
176: #endif /* !GC_MARK_DEBUG */
177:
178: /*
179: * Flags to modify how a GC marks and sweeps:
180: * GC_KEEP_ATOMS Don't sweep unmarked atoms, they may be in use by the
181: * compiler, or by an API function that calls js_Atomize,
182: * when the GC is called from js_AllocGCThing, due to a
183: * malloc failure or the runtime GC-thing limit.
184: * GC_LAST_CONTEXT Called from js_DestroyContext for last JSContext in a
185: * JSRuntime, when it is imperative that rt->gcPoke gets
186: * cleared early in js_GC, if it is set.
187: * GC_ALREADY_LOCKED rt->gcLock is already held on entry to js_GC, and kept
188: * on return to its caller.
189: */
190: #define GC_KEEP_ATOMS 0x1
191: #define GC_LAST_CONTEXT 0x2
192: #define GC_ALREADY_LOCKED 0x4
193:
194: extern void
195: js_ForceGC(JSContext *cx, uintN gcflags);
196:
197: extern void
198: js_GC(JSContext *cx, uintN gcflags);
199:
200: #ifdef JS_GCMETER
201:
202: typedef struct JSGCStats {
203: uint32 alloc; /* number of allocation attempts */
204: uint32 freelen; /* gcFreeList length */
205: uint32 recycle; /* number of things recycled through gcFreeList */
206: uint32 retry; /* allocation attempt retries after running the GC */
207: uint32 fail; /* allocation failures */
208: uint32 finalfail; /* finalizer calls allocator failures */
209: uint32 lock; /* valid lock calls */
210: uint32 unlock; /* valid unlock calls */
211: uint32 stuck; /* stuck reference counts seen by lock calls */
212: uint32 unstuck; /* unlock calls that saw a stuck lock count */
213: uint32 depth; /* mark recursion depth */
214: uint32 maxdepth; /* maximum mark recursion depth */
215: uint32 maxlevel; /* maximum GC nesting (indirect recursion) level */
216: uint32 poke; /* number of potentially useful GC calls */
217: uint32 nopoke; /* useless GC calls where js_PokeGC was not set */
218: uint32 afree; /* thing arenas freed so far */
219: uint32 stackseg; /* total extraordinary stack segments scanned */
220: uint32 segslots; /* total stack segment jsval slots scanned */
221: } JSGCStats;
222:
223: extern void
224: js_DumpGCStats(JSRuntime *rt, FILE *fp);
225:
226: #endif /* JS_GCMETER */
227:
228: JS_END_EXTERN_C
229:
230: #endif /* jsgc_h___ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.