2018-11-30 19:52:05 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
2018-11-30 15:39:55 +00:00
|
|
|
* vim: set ts=8 sts=2 et sw=2 tw=80:
|
2013-04-16 20:47:10 +00:00
|
|
|
* 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/. */
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2017-11-16 12:21:07 +00:00
|
|
|
/*
|
|
|
|
* High-level interface to the JS garbage collector.
|
|
|
|
*/
|
|
|
|
|
2013-06-20 00:59:09 +00:00
|
|
|
#ifndef js_GCAPI_h
|
|
|
|
#define js_GCAPI_h
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2016-12-22 21:43:42 +00:00
|
|
|
#include "mozilla/TimeStamp.h"
|
2015-04-22 16:43:02 +00:00
|
|
|
#include "mozilla/Vector.h"
|
|
|
|
|
2015-09-29 20:39:33 +00:00
|
|
|
#include "js/GCAnnotations.h"
|
2017-12-18 20:45:06 +00:00
|
|
|
#include "js/TypeDecls.h"
|
2016-01-16 00:26:06 +00:00
|
|
|
#include "js/UniquePtr.h"
|
2017-05-02 22:45:43 +00:00
|
|
|
#include "js/Utility.h"
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2017-11-16 12:21:07 +00:00
|
|
|
struct JSFreeOp;
|
|
|
|
|
|
|
|
#ifdef JS_BROKEN_GCC_ATTRIBUTE_WARNING
|
2019-01-18 09:16:18 +00:00
|
|
|
# pragma GCC diagnostic push
|
|
|
|
# pragma GCC diagnostic ignored "-Wattributes"
|
2018-11-30 10:46:48 +00:00
|
|
|
#endif // JS_BROKEN_GCC_ATTRIBUTE_WARNING
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-19 17:02:47 +00:00
|
|
|
class JS_PUBLIC_API JSTracer;
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
#ifdef JS_BROKEN_GCC_ATTRIBUTE_WARNING
|
2019-01-18 09:16:18 +00:00
|
|
|
# pragma GCC diagnostic pop
|
2018-11-30 10:46:48 +00:00
|
|
|
#endif // JS_BROKEN_GCC_ATTRIBUTE_WARNING
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2014-05-19 10:09:55 +00:00
|
|
|
namespace js {
|
|
|
|
namespace gc {
|
|
|
|
class GCRuntime;
|
2018-11-30 10:46:48 +00:00
|
|
|
} // namespace gc
|
2015-04-22 16:43:02 +00:00
|
|
|
namespace gcstats {
|
|
|
|
struct Statistics;
|
2018-11-30 10:46:48 +00:00
|
|
|
} // namespace gcstats
|
|
|
|
} // namespace js
|
2014-05-19 10:09:55 +00:00
|
|
|
|
2014-04-16 23:26:33 +00:00
|
|
|
typedef enum JSGCMode {
|
2018-11-30 10:46:48 +00:00
|
|
|
/** Perform only global GCs. */
|
|
|
|
JSGC_MODE_GLOBAL = 0,
|
2014-04-16 23:26:33 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
/** Perform per-zone GCs until too much garbage has accumulated. */
|
|
|
|
JSGC_MODE_ZONE = 1,
|
2014-04-16 23:26:33 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
/**
|
|
|
|
* Collect in short time slices rather than all at once. Implies
|
|
|
|
* JSGC_MODE_ZONE.
|
|
|
|
*/
|
2019-03-26 16:57:40 +00:00
|
|
|
JSGC_MODE_ZONE_INCREMENTAL = 2
|
2014-04-16 23:26:33 +00:00
|
|
|
} JSGCMode;
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2015-01-02 17:19:43 +00:00
|
|
|
* Kinds of js_GC invocation.
|
|
|
|
*/
|
|
|
|
typedef enum JSGCInvocationKind {
|
2018-11-30 10:46:48 +00:00
|
|
|
/* Normal invocation. */
|
|
|
|
GC_NORMAL = 0,
|
2015-01-02 17:19:43 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
/* Minimize GC triggers and release empty GC chunks right away. */
|
|
|
|
GC_SHRINK = 1
|
2015-01-02 17:19:43 +00:00
|
|
|
} JSGCInvocationKind;
|
|
|
|
|
2017-11-16 12:21:07 +00:00
|
|
|
typedef enum JSGCParamKey {
|
2018-11-30 10:46:48 +00:00
|
|
|
/**
|
|
|
|
* Maximum nominal heap before last ditch GC.
|
|
|
|
*
|
|
|
|
* Soft limit on the number of bytes we are allowed to allocate in the GC
|
|
|
|
* heap. Attempts to allocate gcthings over this limit will return null and
|
|
|
|
* subsequently invoke the standard OOM machinery, independent of available
|
|
|
|
* physical memory.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.max
|
|
|
|
* Default: 0xffffffff
|
|
|
|
*/
|
|
|
|
JSGC_MAX_BYTES = 0,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initial value for the malloc bytes threshold.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.high_water_mark
|
|
|
|
* Default: TuningDefaults::MaxMallocBytes
|
|
|
|
*/
|
|
|
|
JSGC_MAX_MALLOC_BYTES = 1,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Maximum size of the generational GC nurseries.
|
|
|
|
*
|
2019-03-22 05:16:21 +00:00
|
|
|
* This will be rounded to the nearest gc::ChunkSize. The special value 0
|
|
|
|
* will disable generational GC.
|
|
|
|
*
|
2018-11-30 10:46:48 +00:00
|
|
|
* Pref: javascript.options.mem.nursery.max_kb
|
|
|
|
* Default: JS::DefaultNurseryBytes
|
|
|
|
*/
|
|
|
|
JSGC_MAX_NURSERY_BYTES = 2,
|
|
|
|
|
|
|
|
/** Amount of bytes allocated by the GC. */
|
|
|
|
JSGC_BYTES = 3,
|
|
|
|
|
|
|
|
/** Number of times GC has been invoked. Includes both major and minor GC. */
|
|
|
|
JSGC_NUMBER = 4,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Select GC mode.
|
|
|
|
*
|
|
|
|
* See: JSGCMode in GCAPI.h
|
|
|
|
* prefs: javascript.options.mem.gc_per_zone and
|
|
|
|
* javascript.options.mem.gc_incremental.
|
2019-03-26 16:57:40 +00:00
|
|
|
* Default: JSGC_MODE_ZONE_INCREMENTAL
|
2018-11-30 10:46:48 +00:00
|
|
|
*/
|
|
|
|
JSGC_MODE = 6,
|
|
|
|
|
|
|
|
/** Number of cached empty GC chunks. */
|
|
|
|
JSGC_UNUSED_CHUNKS = 7,
|
|
|
|
|
|
|
|
/** Total number of allocated GC chunks. */
|
|
|
|
JSGC_TOTAL_CHUNKS = 8,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Max milliseconds to spend in an incremental GC slice.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_incremental_slice_ms
|
|
|
|
* Default: DefaultTimeBudget.
|
|
|
|
*/
|
|
|
|
JSGC_SLICE_TIME_BUDGET = 9,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Maximum size the GC mark stack can grow to.
|
|
|
|
*
|
|
|
|
* Pref: none
|
|
|
|
* Default: MarkStack::DefaultCapacity
|
|
|
|
*/
|
|
|
|
JSGC_MARK_STACK_LIMIT = 10,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GCs less than this far apart in time will be considered 'high-frequency
|
|
|
|
* GCs'.
|
|
|
|
*
|
|
|
|
* See setGCLastBytes in jsgc.cpp.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_high_frequency_time_limit_ms
|
|
|
|
* Default: HighFrequencyThreshold
|
|
|
|
*/
|
|
|
|
JSGC_HIGH_FREQUENCY_TIME_LIMIT = 11,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Start of dynamic heap growth.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_high_frequency_low_limit_mb
|
|
|
|
* Default: HighFrequencyLowLimitBytes
|
|
|
|
*/
|
|
|
|
JSGC_HIGH_FREQUENCY_LOW_LIMIT = 12,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* End of dynamic heap growth.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_high_frequency_high_limit_mb
|
|
|
|
* Default: HighFrequencyHighLimitBytes
|
|
|
|
*/
|
|
|
|
JSGC_HIGH_FREQUENCY_HIGH_LIMIT = 13,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Upper bound of heap growth.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_high_frequency_heap_growth_max
|
|
|
|
* Default: HighFrequencyHeapGrowthMax
|
|
|
|
*/
|
|
|
|
JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX = 14,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Lower bound of heap growth.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_high_frequency_heap_growth_min
|
|
|
|
* Default: HighFrequencyHeapGrowthMin
|
|
|
|
*/
|
|
|
|
JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN = 15,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Heap growth for low frequency GCs.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_low_frequency_heap_growth
|
|
|
|
* Default: LowFrequencyHeapGrowth
|
|
|
|
*/
|
|
|
|
JSGC_LOW_FREQUENCY_HEAP_GROWTH = 16,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If false, the heap growth factor is fixed at 3. If true, it is determined
|
|
|
|
* based on whether GCs are high- or low- frequency.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_dynamic_heap_growth
|
|
|
|
* Default: DynamicHeapGrowthEnabled
|
|
|
|
*/
|
|
|
|
JSGC_DYNAMIC_HEAP_GROWTH = 17,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If true, high-frequency GCs will use a longer mark slice.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_dynamic_mark_slice
|
|
|
|
* Default: DynamicMarkSliceEnabled
|
|
|
|
*/
|
|
|
|
JSGC_DYNAMIC_MARK_SLICE = 18,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Lower limit after which we limit the heap growth.
|
|
|
|
*
|
|
|
|
* The base value used to compute zone->threshold.gcTriggerBytes(). When
|
|
|
|
* usage.gcBytes() surpasses threshold.gcTriggerBytes() for a zone, the
|
|
|
|
* zone may be scheduled for a GC, depending on the exact circumstances.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_allocation_threshold_mb
|
|
|
|
* Default GCZoneAllocThresholdBase
|
|
|
|
*/
|
|
|
|
JSGC_ALLOCATION_THRESHOLD = 19,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* We try to keep at least this many unused chunks in the free chunk pool at
|
|
|
|
* all times, even after a shrinking GC.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_min_empty_chunk_count
|
|
|
|
* Default: MinEmptyChunkCount
|
|
|
|
*/
|
|
|
|
JSGC_MIN_EMPTY_CHUNK_COUNT = 21,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* We never keep more than this many unused chunks in the free chunk
|
|
|
|
* pool.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_min_empty_chunk_count
|
|
|
|
* Default: MinEmptyChunkCount
|
|
|
|
*/
|
|
|
|
JSGC_MAX_EMPTY_CHUNK_COUNT = 22,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Whether compacting GC is enabled.
|
|
|
|
*
|
|
|
|
* Pref: javascript.options.mem.gc_compacting
|
|
|
|
* Default: CompactingEnabled
|
|
|
|
*/
|
|
|
|
JSGC_COMPACTING_ENABLED = 23,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Factor for triggering a GC based on JSGC_ALLOCATION_THRESHOLD
|
|
|
|
*
|
|
|
|
* Default: ZoneAllocThresholdFactorDefault
|
|
|
|
* Pref: None
|
|
|
|
*/
|
|
|
|
JSGC_ALLOCATION_THRESHOLD_FACTOR = 25,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Factor for triggering a GC based on JSGC_ALLOCATION_THRESHOLD.
|
|
|
|
* Used if another GC (in different zones) is already running.
|
|
|
|
*
|
|
|
|
* Default: ZoneAllocThresholdFactorAvoidInterruptDefault
|
|
|
|
* Pref: None
|
|
|
|
*/
|
|
|
|
JSGC_ALLOCATION_THRESHOLD_FACTOR_AVOID_INTERRUPT = 26,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Attempt to run a minor GC in the idle time if the free space falls
|
|
|
|
* below this threshold.
|
|
|
|
*
|
|
|
|
* Default: NurseryChunkUsableSize / 4
|
|
|
|
* Pref: None
|
|
|
|
*/
|
|
|
|
JSGC_NURSERY_FREE_THRESHOLD_FOR_IDLE_COLLECTION = 27,
|
2018-12-14 00:25:10 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* If this percentage of the nursery is tenured, then proceed to examine which
|
|
|
|
* groups we should pretenure.
|
|
|
|
*
|
|
|
|
* Default: PretenureThreshold
|
|
|
|
* Pref: None
|
|
|
|
*/
|
|
|
|
JSGC_PRETENURE_THRESHOLD = 28,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If the above condition is met, then any object group that tenures more than
|
|
|
|
* this number of objects will be pretenured (if it can be).
|
|
|
|
*
|
|
|
|
* Default: PretenureGroupThreshold
|
|
|
|
* Pref: None
|
|
|
|
*/
|
|
|
|
JSGC_PRETENURE_GROUP_THRESHOLD = 29,
|
2019-02-27 03:36:54 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Attempt to run a minor GC in the idle time if the free space falls
|
|
|
|
* below this percentage (from 0 to 99).
|
|
|
|
*
|
|
|
|
* Default: 25
|
|
|
|
* Pref: None
|
|
|
|
*/
|
|
|
|
JSGC_NURSERY_FREE_THRESHOLD_FOR_IDLE_COLLECTION_PERCENT = 30,
|
|
|
|
|
2019-03-22 05:16:21 +00:00
|
|
|
/**
|
|
|
|
* Minimum size of the generational GC nurseries.
|
|
|
|
*
|
|
|
|
* This value will be rounded to the nearest Nursery::SubChunkStep if below
|
|
|
|
* gc::ChunkSize, otherwise it'll be rounded to the nearest gc::ChunkSize.
|
|
|
|
*
|
|
|
|
* Default: Nursery::SubChunkLimit
|
|
|
|
* Pref: None
|
|
|
|
*/
|
|
|
|
JSGC_MIN_NURSERY_BYTES = 31,
|
|
|
|
|
2017-11-16 12:21:07 +00:00
|
|
|
} JSGCParamKey;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Generic trace operation that calls JS::TraceEdge on each traceable thing's
|
|
|
|
* location reachable from data.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*JSTraceDataOp)(JSTracer* trc, void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef enum JSGCStatus { JSGC_BEGIN, JSGC_END } JSGCStatus;
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*JSGCCallback)(JSContext* cx, JSGCStatus status, void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*JSObjectsTenuredCallback)(JSContext* cx, void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
typedef enum JSFinalizeStatus {
|
2018-11-30 10:46:48 +00:00
|
|
|
/**
|
|
|
|
* Called when preparing to sweep a group of zones, before anything has been
|
|
|
|
* swept. The collector will not yield to the mutator before calling the
|
|
|
|
* callback with JSFINALIZE_GROUP_START status.
|
|
|
|
*/
|
|
|
|
JSFINALIZE_GROUP_PREPARE,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Called after preparing to sweep a group of zones. Weak references to
|
|
|
|
* unmarked things have been removed at this point, but no GC things have
|
|
|
|
* been swept. The collector may yield to the mutator after this point.
|
|
|
|
*/
|
|
|
|
JSFINALIZE_GROUP_START,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Called after sweeping a group of zones. All dead GC things have been
|
|
|
|
* swept at this point.
|
|
|
|
*/
|
|
|
|
JSFINALIZE_GROUP_END,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Called at the end of collection when everything has been swept.
|
|
|
|
*/
|
|
|
|
JSFINALIZE_COLLECTION_END
|
2017-11-16 12:21:07 +00:00
|
|
|
} JSFinalizeStatus;
|
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*JSFinalizeCallback)(JSFreeOp* fop, JSFinalizeStatus status,
|
|
|
|
void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*JSWeakPointerZonesCallback)(JSContext* cx, void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*JSWeakPointerCompartmentCallback)(JSContext* cx,
|
|
|
|
JS::Compartment* comp,
|
|
|
|
void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Finalizes external strings created by JS_NewExternalString. The finalizer
|
|
|
|
* can be called off the main thread.
|
|
|
|
*/
|
|
|
|
struct JSStringFinalizer {
|
2018-11-30 10:46:48 +00:00
|
|
|
void (*finalize)(const JSStringFinalizer* fin, char16_t* chars);
|
2017-11-16 12:21:07 +00:00
|
|
|
};
|
|
|
|
|
2013-01-27 20:35:12 +00:00
|
|
|
namespace JS {
|
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
#define GCREASONS(D) \
|
|
|
|
/* Reasons internal to the JS engine */ \
|
|
|
|
D(API, 0) \
|
|
|
|
D(EAGER_ALLOC_TRIGGER, 1) \
|
|
|
|
D(DESTROY_RUNTIME, 2) \
|
|
|
|
D(ROOTS_REMOVED, 3) \
|
|
|
|
D(LAST_DITCH, 4) \
|
|
|
|
D(TOO_MUCH_MALLOC, 5) \
|
|
|
|
D(ALLOC_TRIGGER, 6) \
|
|
|
|
D(DEBUG_GC, 7) \
|
|
|
|
D(COMPARTMENT_REVIVED, 8) \
|
|
|
|
D(RESET, 9) \
|
|
|
|
D(OUT_OF_NURSERY, 10) \
|
|
|
|
D(EVICT_NURSERY, 11) \
|
|
|
|
D(DELAYED_ATOMS_GC, 12) \
|
|
|
|
D(SHARED_MEMORY_LIMIT, 13) \
|
|
|
|
D(IDLE_TIME_COLLECTION, 14) \
|
|
|
|
D(INCREMENTAL_TOO_SLOW, 15) \
|
|
|
|
D(ABORT_GC, 16) \
|
|
|
|
D(FULL_WHOLE_CELL_BUFFER, 17) \
|
|
|
|
D(FULL_GENERIC_BUFFER, 18) \
|
|
|
|
D(FULL_VALUE_BUFFER, 19) \
|
|
|
|
D(FULL_CELL_PTR_BUFFER, 20) \
|
|
|
|
D(FULL_SLOT_BUFFER, 21) \
|
|
|
|
D(FULL_SHAPE_BUFFER, 22) \
|
|
|
|
D(TOO_MUCH_WASM_MEMORY, 23) \
|
2019-01-24 12:34:55 +00:00
|
|
|
D(DISABLE_GENERATIONAL_GC, 24) \
|
|
|
|
D(FINISH_GC, 25) \
|
|
|
|
D(PREPARE_FOR_TRACING, 26) \
|
2018-11-30 10:46:48 +00:00
|
|
|
\
|
|
|
|
/* These are reserved for future use. */ \
|
|
|
|
D(RESERVED3, 27) \
|
|
|
|
D(RESERVED4, 28) \
|
|
|
|
D(RESERVED5, 29) \
|
|
|
|
D(RESERVED6, 30) \
|
|
|
|
D(RESERVED7, 31) \
|
|
|
|
D(RESERVED8, 32) \
|
|
|
|
\
|
|
|
|
/* Reasons from Firefox */ \
|
|
|
|
D(DOM_WINDOW_UTILS, 33) \
|
|
|
|
D(COMPONENT_UTILS, 34) \
|
|
|
|
D(MEM_PRESSURE, 35) \
|
|
|
|
D(CC_WAITING, 36) \
|
|
|
|
D(CC_FORCED, 37) \
|
|
|
|
D(LOAD_END, 38) \
|
2019-01-24 12:34:55 +00:00
|
|
|
D(UNUSED3, 39) \
|
2018-11-30 10:46:48 +00:00
|
|
|
D(PAGE_HIDE, 40) \
|
|
|
|
D(NSJSCONTEXT_DESTROY, 41) \
|
2019-01-24 12:34:55 +00:00
|
|
|
D(WORKER_SHUTDOWN, 42) \
|
2018-11-30 10:46:48 +00:00
|
|
|
D(SET_DOC_SHELL, 43) \
|
|
|
|
D(DOM_UTILS, 44) \
|
|
|
|
D(DOM_IPC, 45) \
|
|
|
|
D(DOM_WORKER, 46) \
|
|
|
|
D(INTER_SLICE_GC, 47) \
|
|
|
|
D(UNUSED1, 48) \
|
|
|
|
D(FULL_GC_TIMER, 49) \
|
|
|
|
D(SHUTDOWN_CC, 50) \
|
|
|
|
D(UNUSED2, 51) \
|
|
|
|
D(USER_INACTIVE, 52) \
|
|
|
|
D(XPCONNECT_SHUTDOWN, 53) \
|
|
|
|
D(DOCSHELL, 54) \
|
|
|
|
D(HTML_PARSER, 55)
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2019-01-21 13:09:12 +00:00
|
|
|
enum class GCReason {
|
2018-10-29 10:23:57 +00:00
|
|
|
#define MAKE_REASON(name, val) name = val,
|
2018-11-30 10:46:48 +00:00
|
|
|
GCREASONS(MAKE_REASON)
|
2013-01-27 20:35:12 +00:00
|
|
|
#undef MAKE_REASON
|
2018-11-30 10:46:48 +00:00
|
|
|
NO_REASON,
|
|
|
|
NUM_REASONS,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For telemetry, we want to keep a fixed max bucket size over time so we
|
2019-01-21 13:09:12 +00:00
|
|
|
* don't have to switch histograms. 100 is conservative; but the cost of extra
|
|
|
|
* buckets seems to be low while the cost of switching histograms is high.
|
2018-11-30 10:46:48 +00:00
|
|
|
*/
|
|
|
|
NUM_TELEMETRY_REASONS = 100
|
2013-01-27 20:35:12 +00:00
|
|
|
};
|
|
|
|
|
2016-01-19 20:48:22 +00:00
|
|
|
/**
|
|
|
|
* Get a statically allocated C string explaining the given GC reason.
|
|
|
|
*/
|
2019-01-21 13:09:12 +00:00
|
|
|
extern JS_PUBLIC_API const char* ExplainGCReason(JS::GCReason reason);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2014-01-23 19:47:11 +00:00
|
|
|
/*
|
|
|
|
* Zone GC:
|
|
|
|
*
|
|
|
|
* SpiderMonkey's GC is capable of performing a collection on an arbitrary
|
|
|
|
* subset of the zones in the system. This allows an embedding to minimize
|
|
|
|
* collection time by only collecting zones that have run code recently,
|
|
|
|
* ignoring the parts of the heap that are unlikely to have changed.
|
|
|
|
*
|
|
|
|
* When triggering a GC using one of the functions below, it is first necessary
|
|
|
|
* to select the zones to be collected. To do this, you can call
|
|
|
|
* PrepareZoneForGC on each zone, or you can call PrepareForFullGC to select
|
|
|
|
* all zones. Failing to select any zone is an error.
|
|
|
|
*/
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Schedule the given zone to be collected as part of the next GC.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void PrepareZoneForGC(Zone* zone);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Schedule all zones to be collected in the next GC.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void PrepareForFullGC(JSContext* cx);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* When performing an incremental GC, the zones that were selected for the
|
|
|
|
* previous incremental slice must be selected in subsequent slices as well.
|
|
|
|
* This function selects those slices automatically.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void PrepareForIncrementalGC(JSContext* cx);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Returns true if any zone in the system has been scheduled for GC with one of
|
|
|
|
* the functions above or by the JS engine.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool IsGCScheduled(JSContext* cx);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Undoes the effect of the Prepare methods above. The given zone will not be
|
|
|
|
* collected in the next GC.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void SkipZoneForGC(Zone* zone);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
|
|
|
/*
|
2014-01-23 19:47:11 +00:00
|
|
|
* Non-Incremental GC:
|
|
|
|
*
|
|
|
|
* The following functions perform a non-incremental GC.
|
2013-01-27 20:35:12 +00:00
|
|
|
*/
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2015-01-02 17:19:43 +00:00
|
|
|
* Performs a non-incremental collection of all selected zones.
|
|
|
|
*
|
|
|
|
* If the gckind argument is GC_NORMAL, then some objects that are unreachable
|
|
|
|
* from the program may still be alive afterwards because of internal
|
|
|
|
* references; if GC_SHRINK is passed then caches and other temporary references
|
|
|
|
* to objects will be cleared and all unreferenced objects will be removed from
|
|
|
|
* the system.
|
2014-01-23 19:47:11 +00:00
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void NonIncrementalGC(JSContext* cx,
|
|
|
|
JSGCInvocationKind gckind,
|
2019-01-21 13:09:12 +00:00
|
|
|
GCReason reason);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2014-01-23 19:47:11 +00:00
|
|
|
/*
|
|
|
|
* Incremental GC:
|
|
|
|
*
|
|
|
|
* Incremental GC divides the full mark-and-sweep collection into multiple
|
|
|
|
* slices, allowing client JavaScript code to run between each slice. This
|
|
|
|
* allows interactive apps to avoid long collection pauses. Incremental GC does
|
|
|
|
* not make collection take less time, it merely spreads that time out so that
|
|
|
|
* the pauses are less noticable.
|
|
|
|
*
|
|
|
|
* For a collection to be carried out incrementally the following conditions
|
|
|
|
* must be met:
|
|
|
|
* - The collection must be run by calling JS::IncrementalGC() rather than
|
|
|
|
* JS_GC().
|
2019-03-26 16:57:40 +00:00
|
|
|
* - The GC mode must have been set to JSGC_MODE_ZONE_INCREMENTAL with
|
2014-01-23 19:47:11 +00:00
|
|
|
* JS_SetGCParameter().
|
|
|
|
*
|
|
|
|
* Note: Even if incremental GC is enabled and working correctly,
|
|
|
|
* non-incremental collections can still happen when low on memory.
|
|
|
|
*/
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2015-01-02 17:19:43 +00:00
|
|
|
* Begin an incremental collection and perform one slice worth of work. When
|
|
|
|
* this function returns, the collection may not be complete.
|
|
|
|
* IncrementalGCSlice() must be called repeatedly until
|
2016-07-07 07:55:45 +00:00
|
|
|
* !IsIncrementalGCInProgress(cx).
|
2014-01-23 19:47:11 +00:00
|
|
|
*
|
|
|
|
* Note: SpiderMonkey's GC is not realtime. Slices in practice may be longer or
|
|
|
|
* shorter than the requested interval.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void StartIncrementalGC(JSContext* cx,
|
|
|
|
JSGCInvocationKind gckind,
|
2019-01-21 13:09:12 +00:00
|
|
|
GCReason reason,
|
2018-11-30 10:46:48 +00:00
|
|
|
int64_t millis = 0);
|
2015-01-02 17:19:43 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2015-01-02 17:19:43 +00:00
|
|
|
* Perform a slice of an ongoing incremental collection. When this function
|
|
|
|
* returns, the collection may not be complete. It must be called repeatedly
|
2016-07-07 07:55:45 +00:00
|
|
|
* until !IsIncrementalGCInProgress(cx).
|
2015-01-02 17:19:43 +00:00
|
|
|
*
|
|
|
|
* Note: SpiderMonkey's GC is not realtime. Slices in practice may be longer or
|
|
|
|
* shorter than the requested interval.
|
|
|
|
*/
|
2019-01-21 13:09:12 +00:00
|
|
|
extern JS_PUBLIC_API void IncrementalGCSlice(JSContext* cx, GCReason reason,
|
2018-11-30 10:46:48 +00:00
|
|
|
int64_t millis = 0);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2016-07-07 07:55:45 +00:00
|
|
|
* If IsIncrementalGCInProgress(cx), this call finishes the ongoing collection
|
|
|
|
* by performing an arbitrarily long slice. If !IsIncrementalGCInProgress(cx),
|
2018-05-24 23:19:18 +00:00
|
|
|
* this is equivalent to NonIncrementalGC. When this function returns,
|
2016-07-07 07:55:45 +00:00
|
|
|
* IsIncrementalGCInProgress(cx) will always be false.
|
2014-01-23 19:47:11 +00:00
|
|
|
*/
|
2019-01-21 13:09:12 +00:00
|
|
|
extern JS_PUBLIC_API void FinishIncrementalGC(JSContext* cx, GCReason reason);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2016-07-07 07:55:45 +00:00
|
|
|
* If IsIncrementalGCInProgress(cx), this call aborts the ongoing collection and
|
2015-04-13 15:42:41 +00:00
|
|
|
* performs whatever work needs to be done to return the collector to its idle
|
|
|
|
* state. This may take an arbitrarily long time. When this function returns,
|
2016-07-07 07:55:45 +00:00
|
|
|
* IsIncrementalGCInProgress(cx) will always be false.
|
2015-04-13 15:42:41 +00:00
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void AbortIncrementalGC(JSContext* cx);
|
2015-04-13 15:42:41 +00:00
|
|
|
|
2015-04-22 16:43:02 +00:00
|
|
|
namespace dbg {
|
|
|
|
|
|
|
|
// The `JS::dbg::GarbageCollectionEvent` class is essentially a view of the
|
|
|
|
// `js::gcstats::Statistics` data without the uber implementation-specific bits.
|
|
|
|
// It should generally be palatable for web developers.
|
2018-11-30 10:46:48 +00:00
|
|
|
class GarbageCollectionEvent {
|
|
|
|
// The major GC number of the GC cycle this data pertains to.
|
|
|
|
uint64_t majorGCNumber_;
|
|
|
|
|
|
|
|
// Reference to a non-owned, statically allocated C string. This is a very
|
|
|
|
// short reason explaining why a GC was triggered.
|
|
|
|
const char* reason;
|
|
|
|
|
|
|
|
// Reference to a nullable, non-owned, statically allocated C string. If the
|
|
|
|
// collection was forced to be non-incremental, this is a short reason of
|
|
|
|
// why the GC could not perform an incremental collection.
|
|
|
|
const char* nonincrementalReason;
|
|
|
|
|
|
|
|
// Represents a single slice of a possibly multi-slice incremental garbage
|
|
|
|
// collection.
|
|
|
|
struct Collection {
|
|
|
|
mozilla::TimeStamp startTimestamp;
|
|
|
|
mozilla::TimeStamp endTimestamp;
|
|
|
|
};
|
|
|
|
|
|
|
|
// The set of garbage collection slices that made up this GC cycle.
|
|
|
|
mozilla::Vector<Collection> collections;
|
|
|
|
|
|
|
|
GarbageCollectionEvent(const GarbageCollectionEvent& rhs) = delete;
|
|
|
|
GarbageCollectionEvent& operator=(const GarbageCollectionEvent& rhs) = delete;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit GarbageCollectionEvent(uint64_t majorGCNum)
|
|
|
|
: majorGCNumber_(majorGCNum),
|
|
|
|
reason(nullptr),
|
|
|
|
nonincrementalReason(nullptr),
|
|
|
|
collections() {}
|
|
|
|
|
|
|
|
using Ptr = js::UniquePtr<GarbageCollectionEvent>;
|
|
|
|
static Ptr Create(JSRuntime* rt, ::js::gcstats::Statistics& stats,
|
|
|
|
uint64_t majorGCNumber);
|
|
|
|
|
|
|
|
JSObject* toJSObject(JSContext* cx) const;
|
|
|
|
|
|
|
|
uint64_t majorGCNumber() const { return majorGCNumber_; }
|
2015-04-22 16:43:02 +00:00
|
|
|
};
|
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
} // namespace dbg
|
2015-04-22 16:43:02 +00:00
|
|
|
|
2013-01-27 20:35:12 +00:00
|
|
|
enum GCProgress {
|
2018-11-30 10:46:48 +00:00
|
|
|
/*
|
|
|
|
* During GC, the GC is bracketed by GC_CYCLE_BEGIN/END callbacks. Each
|
|
|
|
* slice between those (whether an incremental or the sole non-incremental
|
|
|
|
* slice) is bracketed by GC_SLICE_BEGIN/GC_SLICE_END.
|
|
|
|
*/
|
|
|
|
|
|
|
|
GC_CYCLE_BEGIN,
|
|
|
|
GC_SLICE_BEGIN,
|
|
|
|
GC_SLICE_END,
|
|
|
|
GC_CYCLE_END
|
2013-01-27 20:35:12 +00:00
|
|
|
};
|
|
|
|
|
2018-11-19 17:02:47 +00:00
|
|
|
struct JS_PUBLIC_API GCDescription {
|
2018-11-30 10:46:48 +00:00
|
|
|
bool isZone_;
|
|
|
|
bool isComplete_;
|
|
|
|
JSGCInvocationKind invocationKind_;
|
2019-01-21 13:09:12 +00:00
|
|
|
GCReason reason_;
|
2018-11-30 10:46:48 +00:00
|
|
|
|
|
|
|
GCDescription(bool isZone, bool isComplete, JSGCInvocationKind kind,
|
2019-01-21 13:09:12 +00:00
|
|
|
GCReason reason)
|
2018-11-30 10:46:48 +00:00
|
|
|
: isZone_(isZone),
|
|
|
|
isComplete_(isComplete),
|
|
|
|
invocationKind_(kind),
|
|
|
|
reason_(reason) {}
|
|
|
|
|
|
|
|
char16_t* formatSliceMessage(JSContext* cx) const;
|
|
|
|
char16_t* formatSummaryMessage(JSContext* cx) const;
|
|
|
|
|
|
|
|
mozilla::TimeStamp startTime(JSContext* cx) const;
|
|
|
|
mozilla::TimeStamp endTime(JSContext* cx) const;
|
|
|
|
mozilla::TimeStamp lastSliceStart(JSContext* cx) const;
|
|
|
|
mozilla::TimeStamp lastSliceEnd(JSContext* cx) const;
|
|
|
|
|
2019-01-17 03:08:30 +00:00
|
|
|
char16_t* formatJSONTelemetry(JSContext* cx, uint64_t timestamp) const;
|
|
|
|
|
|
|
|
JS::UniqueChars sliceToJSONProfiler(JSContext* cx) const;
|
|
|
|
JS::UniqueChars formatJSONProfiler(JSContext* cx) const;
|
2018-11-30 10:46:48 +00:00
|
|
|
|
|
|
|
JS::dbg::GarbageCollectionEvent::Ptr toGCEvent(JSContext* cx) const;
|
2013-01-27 20:35:12 +00:00
|
|
|
};
|
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API UniqueChars MinorGcToJSON(JSContext* cx);
|
2017-04-25 20:24:34 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*GCSliceCallback)(JSContext* cx, GCProgress progress,
|
|
|
|
const GCDescription& desc);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* The GC slice callback is called at the beginning and end of each slice. This
|
|
|
|
* callback may be used for GC notifications as well as to perform additional
|
|
|
|
* marking.
|
|
|
|
*/
|
2018-11-19 17:02:47 +00:00
|
|
|
extern JS_PUBLIC_API GCSliceCallback
|
2016-07-07 07:55:45 +00:00
|
|
|
SetGCSliceCallback(JSContext* cx, GCSliceCallback callback);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2016-01-19 20:48:22 +00:00
|
|
|
/**
|
|
|
|
* Describes the progress of an observed nursery collection.
|
|
|
|
*/
|
|
|
|
enum class GCNurseryProgress {
|
2018-11-30 10:46:48 +00:00
|
|
|
/**
|
|
|
|
* The nursery collection is starting.
|
|
|
|
*/
|
|
|
|
GC_NURSERY_COLLECTION_START,
|
|
|
|
/**
|
|
|
|
* The nursery collection is ending.
|
|
|
|
*/
|
|
|
|
GC_NURSERY_COLLECTION_END
|
2016-01-19 20:48:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A nursery collection callback receives the progress of the nursery collection
|
|
|
|
* and the reason for the collection.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
using GCNurseryCollectionCallback = void (*)(JSContext* cx,
|
|
|
|
GCNurseryProgress progress,
|
2019-01-21 13:09:12 +00:00
|
|
|
GCReason reason);
|
2016-01-19 20:48:22 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the nursery collection callback for the given runtime. When set, it will
|
|
|
|
* be called at the start and end of every nursery collection.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API GCNurseryCollectionCallback SetGCNurseryCollectionCallback(
|
|
|
|
JSContext* cx, GCNurseryCollectionCallback callback);
|
2016-01-19 20:48:22 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
typedef void (*DoCycleCollectionCallback)(JSContext* cx);
|
2016-08-18 20:30:32 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The purge gray callback is called after any COMPARTMENT_REVIVED GC in which
|
|
|
|
* the majority of compartments have been marked gray.
|
|
|
|
*/
|
2018-11-19 17:02:47 +00:00
|
|
|
extern JS_PUBLIC_API DoCycleCollectionCallback
|
2016-08-18 20:30:32 +00:00
|
|
|
SetDoCycleCollectionCallback(JSContext* cx, DoCycleCollectionCallback callback);
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Incremental GC defaults to enabled, but may be disabled for testing or in
|
|
|
|
* embeddings that have not yet implemented barriers on their native classes.
|
|
|
|
* There is not currently a way to re-enable incremental GC once it has been
|
|
|
|
* disabled on the runtime.
|
2013-01-27 20:35:12 +00:00
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void DisableIncrementalGC(JSContext* cx);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Returns true if incremental GC is enabled. Simply having incremental GC
|
|
|
|
* enabled is not sufficient to ensure incremental collections are happening.
|
|
|
|
* See the comment "Incremental GC" above for reasons why incremental GC may be
|
|
|
|
* suppressed. Inspection of the "nonincremental reason" field of the
|
|
|
|
* GCDescription returned by GCSliceCallback may help narrow down the cause if
|
|
|
|
* collections are not happening incrementally when expected.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool IsIncrementalGCEnabled(JSContext* cx);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Returns true while an incremental GC is ongoing, both when actively
|
|
|
|
* collecting and between slices.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool IsIncrementalGCInProgress(JSContext* cx);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2017-04-24 02:30:06 +00:00
|
|
|
/**
|
|
|
|
* Returns true while an incremental GC is ongoing, both when actively
|
|
|
|
* collecting and between slices.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool IsIncrementalGCInProgress(JSRuntime* rt);
|
2017-04-24 02:30:06 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Returns true if the most recent GC ran incrementally.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool WasIncrementalGC(JSRuntime* rt);
|
2014-01-23 19:47:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Generational GC:
|
|
|
|
*
|
2014-02-24 23:08:05 +00:00
|
|
|
* Note: Generational GC is not yet enabled by default. The following class
|
|
|
|
* is non-functional unless SpiderMonkey was configured with
|
2014-01-23 19:47:11 +00:00
|
|
|
* --enable-gcgenerational.
|
|
|
|
*/
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/** Ensure that generational GC is disabled within some scope. */
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoDisableGenerationalGC {
|
|
|
|
JSContext* cx;
|
2014-02-21 23:54:25 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
public:
|
|
|
|
explicit AutoDisableGenerationalGC(JSContext* cx);
|
|
|
|
~AutoDisableGenerationalGC();
|
2014-02-21 23:54:25 +00:00
|
|
|
};
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-01-23 19:47:11 +00:00
|
|
|
* Returns true if generational allocation and collection is currently enabled
|
|
|
|
* on the given runtime.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool IsGenerationalGCEnabled(JSRuntime* rt);
|
2013-01-27 20:35:12 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2016-10-05 23:04:31 +00:00
|
|
|
* Pass a subclass of this "abstract" class to callees to require that they
|
|
|
|
* never GC. Subclasses can use assertions or the hazard analysis to ensure no
|
|
|
|
* GC happens.
|
2014-05-29 00:34:36 +00:00
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoRequireNoGC {
|
|
|
|
protected:
|
|
|
|
AutoRequireNoGC() {}
|
|
|
|
~AutoRequireNoGC() {}
|
2016-10-05 23:04:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2016-10-27 10:03:53 +00:00
|
|
|
* Diagnostic assert (see MOZ_DIAGNOSTIC_ASSERT) that GC cannot occur while this
|
|
|
|
* class is live. This class does not disable the static rooting hazard
|
|
|
|
* analysis.
|
|
|
|
*
|
|
|
|
* This works by entering a GC unsafe region, which is checked on allocation and
|
|
|
|
* on GC.
|
2016-10-05 23:04:31 +00:00
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoAssertNoGC : public AutoRequireNoGC {
|
2017-09-04 06:25:00 +00:00
|
|
|
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
|
2018-11-30 10:46:48 +00:00
|
|
|
JSContext* cx_;
|
2014-05-29 00:34:36 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
public:
|
|
|
|
// This gets the context from TLS if it is not passed in.
|
|
|
|
explicit AutoAssertNoGC(JSContext* cx = nullptr);
|
|
|
|
~AutoAssertNoGC();
|
2017-08-01 08:42:04 +00:00
|
|
|
#else
|
2018-11-30 10:46:48 +00:00
|
|
|
public:
|
|
|
|
explicit AutoAssertNoGC(JSContext* cx = nullptr) {}
|
|
|
|
~AutoAssertNoGC() {}
|
2017-08-01 08:42:04 +00:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2017-09-01 09:13:51 +00:00
|
|
|
* Disable the static rooting hazard analysis in the live region and assert in
|
|
|
|
* debug builds if any allocation that could potentially trigger a GC occurs
|
|
|
|
* while this guard object is live. This is most useful to help the exact
|
|
|
|
* rooting hazard analysis in complex regions, since it cannot understand
|
|
|
|
* dataflow.
|
2014-01-23 19:47:11 +00:00
|
|
|
*
|
2014-10-17 23:57:52 +00:00
|
|
|
* Note: GC behavior is unpredictable even when deterministic and is generally
|
2014-01-23 19:47:11 +00:00
|
|
|
* non-deterministic in practice. The fact that this guard has not
|
|
|
|
* asserted is not a guarantee that a GC cannot happen in the guarded
|
|
|
|
* region. As a rule, anyone performing a GC unsafe action should
|
|
|
|
* understand the GC properties of all code in that region and ensure
|
|
|
|
* that the hazard analysis is correct for that code, rather than relying
|
|
|
|
* on this class.
|
|
|
|
*/
|
2017-09-01 09:13:51 +00:00
|
|
|
#ifdef DEBUG
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoSuppressGCAnalysis : public AutoAssertNoGC {
|
|
|
|
public:
|
|
|
|
explicit AutoSuppressGCAnalysis(JSContext* cx = nullptr)
|
|
|
|
: AutoAssertNoGC(cx) {}
|
2017-09-01 09:13:51 +00:00
|
|
|
} JS_HAZ_GC_SUPPRESSED;
|
|
|
|
#else
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoSuppressGCAnalysis : public AutoRequireNoGC {
|
|
|
|
public:
|
|
|
|
explicit AutoSuppressGCAnalysis(JSContext* cx = nullptr) {}
|
2016-05-19 19:53:29 +00:00
|
|
|
} JS_HAZ_GC_SUPPRESSED;
|
2017-09-01 09:13:51 +00:00
|
|
|
#endif
|
2014-09-19 08:57:11 +00:00
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-09-19 08:57:11 +00:00
|
|
|
* Assert that code is only ever called from a GC callback, disable the static
|
|
|
|
* rooting hazard analysis and assert if any allocation that could potentially
|
|
|
|
* trigger a GC occurs while this guard object is live.
|
|
|
|
*
|
|
|
|
* This is useful to make the static analysis ignore code that runs in GC
|
|
|
|
* callbacks.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoAssertGCCallback : public AutoSuppressGCAnalysis {
|
|
|
|
public:
|
2017-04-25 09:56:34 +00:00
|
|
|
#ifdef DEBUG
|
2018-11-30 10:46:48 +00:00
|
|
|
AutoAssertGCCallback();
|
2017-04-25 09:56:34 +00:00
|
|
|
#else
|
2018-11-30 10:46:48 +00:00
|
|
|
AutoAssertGCCallback() {}
|
2017-04-25 09:56:34 +00:00
|
|
|
#endif
|
2014-05-29 00:34:36 +00:00
|
|
|
};
|
|
|
|
|
2015-10-17 17:27:16 +00:00
|
|
|
/**
|
2014-05-29 00:34:36 +00:00
|
|
|
* Place AutoCheckCannotGC in scopes that you believe can never GC. These
|
2016-10-27 10:03:53 +00:00
|
|
|
* annotations will be verified both dynamically via AutoAssertNoGC, and
|
2014-05-29 00:34:36 +00:00
|
|
|
* statically with the rooting hazard analysis (implemented by making the
|
|
|
|
* analysis consider AutoCheckCannotGC to be a GC pointer, and therefore
|
|
|
|
* complain if it is live across a GC call.) It is useful when dealing with
|
|
|
|
* internal pointers to GC things where the GC thing itself may not be present
|
|
|
|
* for the static analysis: e.g. acquiring inline chars from a JSString* on the
|
|
|
|
* heap.
|
2016-10-05 23:04:31 +00:00
|
|
|
*
|
|
|
|
* We only do the assertion checking in DEBUG builds.
|
2014-05-29 00:34:36 +00:00
|
|
|
*/
|
2016-10-05 23:04:31 +00:00
|
|
|
#ifdef DEBUG
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoCheckCannotGC : public AutoAssertNoGC {
|
|
|
|
public:
|
|
|
|
explicit AutoCheckCannotGC(JSContext* cx = nullptr) : AutoAssertNoGC(cx) {}
|
2015-09-29 20:39:33 +00:00
|
|
|
} JS_HAZ_GC_INVALIDATED;
|
2016-10-05 23:04:31 +00:00
|
|
|
#else
|
2018-11-30 10:46:48 +00:00
|
|
|
class JS_PUBLIC_API AutoCheckCannotGC : public AutoRequireNoGC {
|
|
|
|
public:
|
|
|
|
explicit AutoCheckCannotGC(JSContext* cx = nullptr) {}
|
2016-10-05 23:04:31 +00:00
|
|
|
} JS_HAZ_GC_INVALIDATED;
|
|
|
|
#endif
|
2013-09-17 17:50:03 +00:00
|
|
|
|
2014-01-23 19:47:11 +00:00
|
|
|
/*
|
|
|
|
* Internal to Firefox.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_FRIEND_API void NotifyGCRootsRemoved(JSContext* cx);
|
2014-01-23 19:47:11 +00:00
|
|
|
|
2013-01-27 20:35:12 +00:00
|
|
|
} /* namespace JS */
|
|
|
|
|
2017-11-16 12:21:07 +00:00
|
|
|
/**
|
|
|
|
* Register externally maintained GC roots.
|
|
|
|
*
|
|
|
|
* traceOp: the trace operation. For each root the implementation should call
|
|
|
|
* JS::TraceEdge whenever the root contains a traceable thing.
|
|
|
|
* data: the data argument to pass to each invocation of traceOp.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool JS_AddExtraGCRootsTracer(JSContext* cx,
|
|
|
|
JSTraceDataOp traceOp,
|
|
|
|
void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
/** Undo a call to JS_AddExtraGCRootsTracer. */
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_RemoveExtraGCRootsTracer(JSContext* cx,
|
|
|
|
JSTraceDataOp traceOp,
|
|
|
|
void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2019-01-24 12:34:55 +00:00
|
|
|
extern JS_PUBLIC_API void JS_GC(JSContext* cx,
|
|
|
|
JS::GCReason reason = JS::GCReason::API);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_MaybeGC(JSContext* cx);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_SetGCCallback(JSContext* cx, JSGCCallback cb,
|
|
|
|
void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_SetObjectsTenuredCallback(
|
|
|
|
JSContext* cx, JSObjectsTenuredCallback cb, void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool JS_AddFinalizeCallback(JSContext* cx,
|
|
|
|
JSFinalizeCallback cb,
|
|
|
|
void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_RemoveFinalizeCallback(JSContext* cx,
|
|
|
|
JSFinalizeCallback cb);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Weak pointers and garbage collection
|
|
|
|
*
|
|
|
|
* Weak pointers are by their nature not marked as part of garbage collection,
|
|
|
|
* but they may need to be updated in two cases after a GC:
|
|
|
|
*
|
|
|
|
* 1) Their referent was found not to be live and is about to be finalized
|
|
|
|
* 2) Their referent has been moved by a compacting GC
|
|
|
|
*
|
|
|
|
* To handle this, any part of the system that maintain weak pointers to
|
|
|
|
* JavaScript GC things must register a callback with
|
|
|
|
* JS_(Add,Remove)WeakPointer{ZoneGroup,Compartment}Callback(). This callback
|
|
|
|
* must then call JS_UpdateWeakPointerAfterGC() on all weak pointers it knows
|
|
|
|
* about.
|
|
|
|
*
|
|
|
|
* Since sweeping is incremental, we have several callbacks to avoid repeatedly
|
|
|
|
* having to visit all embedder structures. The WeakPointerZonesCallback is
|
|
|
|
* called once for each strongly connected group of zones, whereas the
|
|
|
|
* WeakPointerCompartmentCallback is called once for each compartment that is
|
|
|
|
* visited while sweeping. Structures that cannot contain references in more
|
|
|
|
* than one compartment should sweep the relevant per-compartment structures
|
|
|
|
* using the latter callback to minimizer per-slice overhead.
|
|
|
|
*
|
|
|
|
* The argument to JS_UpdateWeakPointerAfterGC() is an in-out param. If the
|
|
|
|
* referent is about to be finalized the pointer will be set to null. If the
|
|
|
|
* referent has been moved then the pointer will be updated to point to the new
|
|
|
|
* location.
|
|
|
|
*
|
|
|
|
* Callers of this method are responsible for updating any state that is
|
|
|
|
* dependent on the object's address. For example, if the object's address is
|
|
|
|
* used as a key in a hashtable, then the object must be removed and
|
|
|
|
* re-inserted with the correct hash.
|
|
|
|
*/
|
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool JS_AddWeakPointerZonesCallback(
|
|
|
|
JSContext* cx, JSWeakPointerZonesCallback cb, void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_RemoveWeakPointerZonesCallback(
|
|
|
|
JSContext* cx, JSWeakPointerZonesCallback cb);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool JS_AddWeakPointerCompartmentCallback(
|
|
|
|
JSContext* cx, JSWeakPointerCompartmentCallback cb, void* data);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_RemoveWeakPointerCompartmentCallback(
|
|
|
|
JSContext* cx, JSWeakPointerCompartmentCallback cb);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
namespace JS {
|
2018-11-30 10:46:48 +00:00
|
|
|
template <typename T>
|
|
|
|
class Heap;
|
2017-11-16 12:21:07 +00:00
|
|
|
}
|
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_UpdateWeakPointerAfterGC(
|
|
|
|
JS::Heap<JSObject*>* objp);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_UpdateWeakPointerAfterGCUnbarriered(
|
|
|
|
JSObject** objp);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_SetGCParameter(JSContext* cx, JSGCParamKey key,
|
|
|
|
uint32_t value);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_ResetGCParameter(JSContext* cx, JSGCParamKey key);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API uint32_t JS_GetGCParameter(JSContext* cx,
|
|
|
|
JSGCParamKey key);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void JS_SetGCParametersBasedOnAvailableMemory(
|
|
|
|
JSContext* cx, uint32_t availMem);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a new JSString whose chars member refers to external memory, i.e.,
|
|
|
|
* memory requiring application-specific finalization.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API JSString* JS_NewExternalString(
|
|
|
|
JSContext* cx, const char16_t* chars, size_t length,
|
|
|
|
const JSStringFinalizer* fin);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a new JSString whose chars member may refer to external memory.
|
|
|
|
* If a new external string is allocated, |*allocatedExternal| is set to true.
|
|
|
|
* Otherwise the returned string is either not an external string or an
|
|
|
|
* external string allocated by a previous call and |*allocatedExternal| is set
|
|
|
|
* to false. If |*allocatedExternal| is false, |fin| won't be called.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API JSString* JS_NewMaybeExternalString(
|
|
|
|
JSContext* cx, const char16_t* chars, size_t length,
|
|
|
|
const JSStringFinalizer* fin, bool* allocatedExternal);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return whether 'str' was created with JS_NewExternalString or
|
|
|
|
* JS_NewExternalStringWithClosure.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool JS_IsExternalString(JSString* str);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the 'fin' arg passed to JS_NewExternalString.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API const JSStringFinalizer* JS_GetExternalStringFinalizer(
|
|
|
|
JSString* str);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
namespace JS {
|
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API bool IsIdleGCTaskNeeded(JSRuntime* rt);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API void RunIdleTimeGCTask(JSRuntime* rt);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2018-11-30 10:46:48 +00:00
|
|
|
} // namespace JS
|
2017-11-16 12:21:07 +00:00
|
|
|
|
2017-11-16 12:21:07 +00:00
|
|
|
namespace js {
|
|
|
|
namespace gc {
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create an object providing access to the garbage collector's internal notion
|
|
|
|
* of the current state of memory (both GC heap memory and GCthing-controlled
|
|
|
|
* malloc memory.
|
|
|
|
*/
|
2018-11-30 10:46:48 +00:00
|
|
|
extern JS_PUBLIC_API JSObject* NewMemoryInfoObject(JSContext* cx);
|
2017-11-16 12:21:07 +00:00
|
|
|
|
|
|
|
} /* namespace gc */
|
|
|
|
} /* namespace js */
|
|
|
|
|
2013-06-20 00:59:09 +00:00
|
|
|
#endif /* js_GCAPI_h */
|