Return to jsgc.h CVS log

Up to [Synchronet] / sbbs / include / mozilla / js

Annotation of sbbs/include/mozilla/js/jsgc.h, revision 1.1

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.