| /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- |
| * vim: set ts=8 sts=4 et sw=4 tw=99: |
| * This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| #ifndef js_GCAPI_h |
| #define js_GCAPI_h |
| |
| #include "HeapAPI.h" |
| #include "jsfriendapi.h" |
| |
| namespace JS { |
| |
| #define GCREASONS(D) \ |
| /* Reasons internal to the JS engine */ \ |
| D(API) \ |
| D(MAYBEGC) \ |
| D(LAST_CONTEXT) \ |
| D(DESTROY_CONTEXT) \ |
| D(LAST_DITCH) \ |
| D(TOO_MUCH_MALLOC) \ |
| D(ALLOC_TRIGGER) \ |
| D(DEBUG_GC) \ |
| D(DEBUG_MODE_GC) \ |
| D(TRANSPLANT) \ |
| D(RESET) \ |
| D(OUT_OF_NURSERY) \ |
| D(EVICT_NURSERY) \ |
| D(FULL_STORE_BUFFER) \ |
| \ |
| /* These are reserved for future use. */ \ |
| D(RESERVED0) \ |
| D(RESERVED1) \ |
| D(RESERVED2) \ |
| D(RESERVED3) \ |
| D(RESERVED4) \ |
| D(RESERVED5) \ |
| D(RESERVED6) \ |
| D(RESERVED7) \ |
| D(RESERVED8) \ |
| D(RESERVED9) \ |
| D(RESERVED10) \ |
| D(RESERVED11) \ |
| D(RESERVED12) \ |
| D(RESERVED13) \ |
| D(RESERVED14) \ |
| D(RESERVED15) \ |
| D(RESERVED16) \ |
| D(RESERVED17) \ |
| D(RESERVED18) \ |
| D(RESERVED19) \ |
| \ |
| /* Reasons from Firefox */ \ |
| D(DOM_WINDOW_UTILS) \ |
| D(COMPONENT_UTILS) \ |
| D(MEM_PRESSURE) \ |
| D(CC_WAITING) \ |
| D(CC_FORCED) \ |
| D(LOAD_END) \ |
| D(POST_COMPARTMENT) \ |
| D(PAGE_HIDE) \ |
| D(NSJSCONTEXT_DESTROY) \ |
| D(SET_NEW_DOCUMENT) \ |
| D(SET_DOC_SHELL) \ |
| D(DOM_UTILS) \ |
| D(DOM_IPC) \ |
| D(DOM_WORKER) \ |
| D(INTER_SLICE_GC) \ |
| D(REFRESH_FRAME) \ |
| D(FULL_GC_TIMER) \ |
| D(SHUTDOWN_CC) \ |
| D(FINISH_LARGE_EVALUTE) |
| |
| namespace gcreason { |
| |
| /* GCReasons will end up looking like JSGC_MAYBEGC */ |
| enum Reason { |
| #define MAKE_REASON(name) name, |
| GCREASONS(MAKE_REASON) |
| #undef MAKE_REASON |
| NO_REASON, |
| NUM_REASONS, |
| |
| /* |
| * For telemetry, we want to keep a fixed max bucket size over time so we |
| * don't have to switch histograms. 100 is conservative; as of this writing |
| * there are 26. But the cost of extra buckets seems to be low while the |
| * cost of switching histograms is high. |
| */ |
| NUM_TELEMETRY_REASONS = 100 |
| }; |
| |
| } /* namespace gcreason */ |
| |
| extern JS_FRIEND_API(void) |
| PrepareZoneForGC(Zone *zone); |
| |
| extern JS_FRIEND_API(void) |
| PrepareForFullGC(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(void) |
| PrepareForIncrementalGC(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(bool) |
| IsGCScheduled(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(void) |
| SkipZoneForGC(Zone *zone); |
| |
| /* |
| * When triggering a GC using one of the functions below, it is first necessary |
| * to select the compartments to be collected. To do this, you can call |
| * PrepareZoneForGC on each compartment, or you can call PrepareForFullGC |
| * to select all compartments. Failing to select any compartment is an error. |
| */ |
| |
| extern JS_FRIEND_API(void) |
| GCForReason(JSRuntime *rt, gcreason::Reason reason); |
| |
| extern JS_FRIEND_API(void) |
| ShrinkingGC(JSRuntime *rt, gcreason::Reason reason); |
| |
| extern JS_FRIEND_API(void) |
| ShrinkGCBuffers(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(void) |
| IncrementalGC(JSRuntime *rt, gcreason::Reason reason, int64_t millis = 0); |
| |
| extern JS_FRIEND_API(void) |
| FinishIncrementalGC(JSRuntime *rt, gcreason::Reason reason); |
| |
| enum GCProgress { |
| /* |
| * During non-incremental GC, the GC is bracketed by JSGC_CYCLE_BEGIN/END |
| * callbacks. During an incremental GC, the sequence of callbacks is as |
| * follows: |
| * JSGC_CYCLE_BEGIN, JSGC_SLICE_END (first slice) |
| * JSGC_SLICE_BEGIN, JSGC_SLICE_END (second slice) |
| * ... |
| * JSGC_SLICE_BEGIN, JSGC_CYCLE_END (last slice) |
| */ |
| |
| GC_CYCLE_BEGIN, |
| GC_SLICE_BEGIN, |
| GC_SLICE_END, |
| GC_CYCLE_END |
| }; |
| |
| struct JS_FRIEND_API(GCDescription) { |
| bool isCompartment_; |
| |
| GCDescription(bool isCompartment) |
| : isCompartment_(isCompartment) {} |
| |
| jschar *formatMessage(JSRuntime *rt) const; |
| jschar *formatJSON(JSRuntime *rt, uint64_t timestamp) const; |
| }; |
| |
| typedef void |
| (* GCSliceCallback)(JSRuntime *rt, GCProgress progress, const GCDescription &desc); |
| |
| extern JS_FRIEND_API(GCSliceCallback) |
| SetGCSliceCallback(JSRuntime *rt, GCSliceCallback callback); |
| |
| /* |
| * Signals a good place to do an incremental slice, because the browser is |
| * drawing a frame. |
| */ |
| extern JS_FRIEND_API(void) |
| NotifyDidPaint(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(bool) |
| IsIncrementalGCEnabled(JSRuntime *rt); |
| |
| JS_FRIEND_API(bool) |
| IsIncrementalGCInProgress(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(void) |
| DisableIncrementalGC(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(void) |
| DisableGenerationalGC(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(bool) |
| IsIncrementalBarrierNeeded(JSRuntime *rt); |
| |
| extern JS_FRIEND_API(bool) |
| IsIncrementalBarrierNeeded(JSContext *cx); |
| |
| extern JS_FRIEND_API(void) |
| IncrementalReferenceBarrier(void *ptr, JSGCTraceKind kind); |
| |
| extern JS_FRIEND_API(void) |
| IncrementalValueBarrier(const Value &v); |
| |
| extern JS_FRIEND_API(void) |
| IncrementalObjectBarrier(JSObject *obj); |
| |
| extern JS_FRIEND_API(void) |
| PokeGC(JSRuntime *rt); |
| |
| /* Was the most recent GC run incrementally? */ |
| extern JS_FRIEND_API(bool) |
| WasIncrementalGC(JSRuntime *rt); |
| |
| class ObjectPtr |
| { |
| JSObject *value; |
| |
| public: |
| ObjectPtr() : value(NULL) {} |
| |
| ObjectPtr(JSObject *obj) : value(obj) {} |
| |
| /* Always call finalize before the destructor. */ |
| ~ObjectPtr() { JS_ASSERT(!value); } |
| |
| void finalize(JSRuntime *rt) { |
| if (IsIncrementalBarrierNeeded(rt)) |
| IncrementalObjectBarrier(value); |
| value = NULL; |
| } |
| |
| void init(JSObject *obj) { value = obj; } |
| |
| JSObject *get() const { return value; } |
| |
| void writeBarrierPre(JSRuntime *rt) { |
| IncrementalObjectBarrier(value); |
| } |
| |
| bool isAboutToBeFinalized() { |
| return JS_IsAboutToBeFinalized(&value); |
| } |
| |
| ObjectPtr &operator=(JSObject *obj) { |
| IncrementalObjectBarrier(value); |
| value = obj; |
| return *this; |
| } |
| |
| void trace(JSTracer *trc, const char *name) { |
| JS_CallObjectTracer(trc, &value, name); |
| } |
| |
| JSObject &operator*() const { return *value; } |
| JSObject *operator->() const { return value; } |
| operator JSObject *() const { return value; } |
| }; |
| |
| /* |
| * Unsets the gray bit for anything reachable from |thing|. |kind| should not be |
| * JSTRACE_SHAPE. |thing| should be non-null. |
| */ |
| extern JS_FRIEND_API(void) |
| UnmarkGrayGCThingRecursively(void *thing, JSGCTraceKind kind); |
| |
| /* |
| * This should be called when an object that is marked gray is exposed to the JS |
| * engine (by handing it to running JS code or writing it into live JS |
| * data). During incremental GC, since the gray bits haven't been computed yet, |
| * we conservatively mark the object black. |
| */ |
| static JS_ALWAYS_INLINE void |
| ExposeGCThingToActiveJS(void *thing, JSGCTraceKind kind) |
| { |
| JS_ASSERT(kind != JSTRACE_SHAPE); |
| |
| shadow::Runtime *rt = js::gc::GetGCThingRuntime(thing); |
| #ifdef JSGC_GENERATIONAL |
| /* |
| * GC things residing in the nursery cannot be gray: they have no mark bits. |
| * All live objects in the nursery are moved to tenured at the beginning of |
| * each GC slice, so the gray marker never sees nursery things. |
| */ |
| if (uintptr_t(thing) >= rt->gcNurseryStart_ && uintptr_t(thing) < rt->gcNurseryEnd_) |
| return; |
| #endif |
| if (IsIncrementalBarrierNeededOnGCThing(rt, thing, kind)) |
| IncrementalReferenceBarrier(thing, kind); |
| else if (GCThingIsMarkedGray(thing)) |
| UnmarkGrayGCThingRecursively(thing, kind); |
| } |
| |
| static JS_ALWAYS_INLINE void |
| ExposeValueToActiveJS(const Value &v) |
| { |
| if (v.isMarkable()) |
| ExposeGCThingToActiveJS(v.toGCThing(), v.gcKind()); |
| } |
| |
| /* |
| * If a GC is currently marking, mark the object black. |
| */ |
| static JS_ALWAYS_INLINE void |
| MarkGCThingAsLive(JSRuntime *rt_, void *thing, JSGCTraceKind kind) |
| { |
| shadow::Runtime *rt = reinterpret_cast<JS::shadow::Runtime*>(rt_); |
| |
| #ifdef JSGC_GENERATIONAL |
| /* |
| * Any object in the nursery will not be freed during any GC running at that time. |
| */ |
| if (js::gc::IsInsideNursery(rt, thing)) |
| return; |
| #endif |
| if (IsIncrementalBarrierNeededOnGCThing(rt, thing, kind)) |
| IncrementalReferenceBarrier(thing, kind); |
| } |
| |
| static JS_ALWAYS_INLINE void |
| MarkStringAsLive(JSContext *cx, JSString *string) |
| { |
| MarkGCThingAsLive(js::GetRuntime(cx), string, JSTRACE_STRING); |
| } |
| |
| } /* namespace JS */ |
| |
| #endif /* js_GCAPI_h */ |
