diff options
Diffstat (limited to 'js/src/gc/Nursery.h')
| -rw-r--r-- | js/src/gc/Nursery.h | 658 |
1 files changed, 658 insertions, 0 deletions
diff --git a/js/src/gc/Nursery.h b/js/src/gc/Nursery.h new file mode 100644 index 0000000000..2bab1623b0 --- /dev/null +++ b/js/src/gc/Nursery.h @@ -0,0 +1,658 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sw=2 et tw=80: + * + * 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 gc_Nursery_h +#define gc_Nursery_h + +#include "mozilla/EnumeratedArray.h" +#include "mozilla/TimeStamp.h" + +#include <tuple> + +#include "gc/GCEnum.h" +#include "gc/GCProbes.h" +#include "gc/Heap.h" +#include "gc/MallocedBlockCache.h" +#include "gc/Pretenuring.h" +#include "js/AllocPolicy.h" +#include "js/Class.h" +#include "js/GCAPI.h" +#include "js/TypeDecls.h" +#include "js/UniquePtr.h" +#include "js/Utility.h" +#include "js/Vector.h" + +#define FOR_EACH_NURSERY_PROFILE_TIME(_) \ + /* Key Header text */ \ + _(Total, "total") \ + _(TraceValues, "mkVals") \ + _(TraceCells, "mkClls") \ + _(TraceSlots, "mkSlts") \ + _(TraceWasmAnyRefs, "mkWars") \ + _(TraceWholeCells, "mcWCll") \ + _(TraceGenericEntries, "mkGnrc") \ + _(CheckHashTables, "ckTbls") \ + _(MarkRuntime, "mkRntm") \ + _(MarkDebugger, "mkDbgr") \ + _(SweepCaches, "swpCch") \ + _(CollectToObjFP, "colObj") \ + _(CollectToStrFP, "colStr") \ + _(ObjectsTenuredCallback, "tenCB") \ + _(Sweep, "sweep") \ + _(UpdateJitActivations, "updtIn") \ + _(FreeMallocedBuffers, "frSlts") \ + _(FreeTrailerBlocks, "frTrBs") \ + _(ClearNursery, "clear") \ + _(PurgeStringToAtomCache, "pStoA") \ + _(Pretenure, "pretnr") + +template <typename T> +class SharedMem; + +namespace js { + +struct StringStats; +class AutoLockGCBgAlloc; +class ObjectElements; +struct NurseryChunk; +class HeapSlot; +class JSONPrinter; +class MapObject; +class SetObject; +class JS_PUBLIC_API Sprinter; + +namespace gc { +class AutoGCSession; +struct Cell; +class GCSchedulingTunables; +class TenuringTracer; +} // namespace gc + +class Nursery { + public: + explicit Nursery(gc::GCRuntime* gc); + ~Nursery(); + + [[nodiscard]] bool init(AutoLockGCBgAlloc& lock); + + // Number of allocated (ready to use) chunks. + unsigned allocatedChunkCount() const { return chunks_.length(); } + + // Total number of chunks and the capacity of the nursery. Chunks will be + // lazilly allocated and added to the chunks array up to this limit, after + // that the nursery must be collected, this limit may be raised during + // collection. + unsigned maxChunkCount() const { + MOZ_ASSERT(capacity()); + return HowMany(capacity(), gc::ChunkSize); + } + + void enable(); + void disable(); + bool isEnabled() const { return capacity() != 0; } + + void enableStrings(); + void disableStrings(); + bool canAllocateStrings() const { return canAllocateStrings_; } + + void enableBigInts(); + void disableBigInts(); + bool canAllocateBigInts() const { return canAllocateBigInts_; } + + // Return true if no allocations have been made since the last collection. + bool isEmpty() const; + + // Check whether an arbitrary pointer is within the nursery. This is + // slower than IsInsideNursery(Cell*), but works on all types of pointers. + MOZ_ALWAYS_INLINE bool isInside(gc::Cell* cellp) const = delete; + MOZ_ALWAYS_INLINE bool isInside(const void* p) const { + for (auto* chunk : chunks_) { + if (uintptr_t(p) - uintptr_t(chunk) < gc::ChunkSize) { + return true; + } + } + return false; + } + + template <typename T> + inline bool isInside(const SharedMem<T>& p) const; + + // Allocate and return a pointer to a new GC thing. Returns nullptr if the + // Nursery is full. + void* allocateCell(gc::AllocSite* site, size_t size, JS::TraceKind kind); + + // Allocate and return a pointer to a new GC thing. Returns nullptr if the + // handleAllocationFailure() needs to be called before retrying. + inline void* tryAllocateCell(gc::AllocSite* site, size_t size, + JS::TraceKind kind); + + // Attempt to handle the failure of tryAllocate. Returns a GCReason if minor + // GC is required, or NO_REASON if the failure was handled and allocation will + // now succeed. + [[nodiscard]] JS::GCReason handleAllocationFailure(); + + static size_t nurseryCellHeaderSize() { + return sizeof(gc::NurseryCellHeader); + } + + // Allocate a buffer for a given zone, using the nursery if possible. Returns + // <buffer, isMalloced> so the caller can register the buffer if + // needed. Returns false in |isMalloced| if the allocation fails. + // + // Use the following API if the owning Cell is already known. + std::tuple<void*, bool> allocateBuffer(JS::Zone* zone, size_t nbytes, + arena_id_t arenaId); + + // Allocate a buffer for a given Cell, using the nursery if possible and + // owner is in the nursery. + void* allocateBuffer(JS::Zone* zone, gc::Cell* owner, size_t nbytes, + arena_id_t arenaId); + + // Allocate a buffer for a given Cell, always using the nursery if |owner| is + // in the nursery. The requested size must be less than or equal to + // MaxNurseryBufferSize. + void* allocateBufferSameLocation(gc::Cell* owner, size_t nbytes, + arena_id_t arenaId); + + // Allocate a zero-initialized buffer for a given zone, using the nursery if + // possible. If the buffer isn't allocated in the nursery, the given arena is + // used. Returns <buffer, isMalloced>. Returns false in |isMalloced| if the + // allocation fails. + std::tuple<void*, bool> allocateZeroedBuffer(JS::Zone* zone, size_t nbytes, + arena_id_t arena); + + // Allocate a zero-initialized buffer for a given Cell, using the nursery if + // possible and |owner| is in the nursery. If the buffer isn't allocated in + // the nursery, the given arena is used. + void* allocateZeroedBuffer(gc::Cell* owner, size_t nbytes, arena_id_t arena); + + // Resize an existing buffer. + void* reallocateBuffer(JS::Zone* zone, gc::Cell* cell, void* oldBuffer, + size_t oldBytes, size_t newBytes, arena_id_t arena); + + // Free an object buffer. + void freeBuffer(void* buffer, size_t nbytes); + + // The maximum number of bytes allowed to reside in nursery buffers. + static const size_t MaxNurseryBufferSize = 1024; + + // Do a minor collection. + void collect(JS::GCOptions options, JS::GCReason reason); + + // If the thing at |*ref| in the Nursery has been forwarded, set |*ref| to + // the new location and return true. Otherwise return false and leave + // |*ref| unset. + [[nodiscard]] MOZ_ALWAYS_INLINE static bool getForwardedPointer( + js::gc::Cell** ref); + + // Forward a slots/elements pointer stored in an Ion frame. + void forwardBufferPointer(uintptr_t* pSlotsElems); + + inline void maybeSetForwardingPointer(JSTracer* trc, void* oldData, + void* newData, bool direct); + inline void setForwardingPointerWhileTenuring(void* oldData, void* newData, + bool direct); + + // Handle an external buffer when a cell is promoted. Updates the pointer to + // the (possibly moved) buffer and returns whether it was moved. + enum WasBufferMoved : bool { BufferNotMoved = false, BufferMoved = true }; + WasBufferMoved maybeMoveRawBufferOnPromotion(void** bufferp, gc::Cell* owner, + size_t nbytes, MemoryUse use, + arena_id_t arena); + template <typename T> + WasBufferMoved maybeMoveBufferOnPromotion(T** bufferp, gc::Cell* owner, + size_t nbytes, MemoryUse use, + arena_id_t arena) { + return maybeMoveRawBufferOnPromotion(reinterpret_cast<void**>(bufferp), + owner, nbytes, use, arena); + } + template <typename T> + WasBufferMoved maybeMoveBufferOnPromotion(T** bufferp, gc::Cell* owner, + size_t nbytes, MemoryUse use) { + return maybeMoveBufferOnPromotion(bufferp, owner, nbytes, use, MallocArena); + } + + // Register a malloced buffer that is held by a nursery object, which + // should be freed at the end of a minor GC. Buffers are unregistered when + // their owning objects are tenured. + [[nodiscard]] bool registerMallocedBuffer(void* buffer, size_t nbytes); + + // Mark a malloced buffer as no longer needing to be freed. + void removeMallocedBuffer(void* buffer, size_t nbytes) { + MOZ_ASSERT(mallocedBuffers.has(buffer)); + MOZ_ASSERT(nbytes > 0); + MOZ_ASSERT(mallocedBufferBytes >= nbytes); + mallocedBuffers.remove(buffer); + mallocedBufferBytes -= nbytes; + } + + // Mark a malloced buffer as no longer needing to be freed during minor + // GC. There's no need to account for the size here since all remaining + // buffers will soon be freed. + void removeMallocedBufferDuringMinorGC(void* buffer) { + MOZ_ASSERT(JS::RuntimeHeapIsMinorCollecting()); + MOZ_ASSERT(mallocedBuffers.has(buffer)); + mallocedBuffers.remove(buffer); + } + + [[nodiscard]] bool addedUniqueIdToCell(gc::Cell* cell) { + MOZ_ASSERT(IsInsideNursery(cell)); + MOZ_ASSERT(isEnabled()); + return cellsWithUid_.append(cell); + } + + size_t sizeOfMallocedBuffers(mozilla::MallocSizeOf mallocSizeOf) const; + + // Wasm "trailer" (C++-heap-allocated) blocks. + // + // All involved blocks are allocated/deallocated via this nursery's + // `mallocedBlockCache_`. Hence we must store both the block address and + // its freelist ID, wrapped up in a PointerAndUint7. + // + // Trailer blocks registered here are added to `trailersAdded_`. Those that + // are later deregistered as a result of `obj_moved` calls that indicate + // tenuring, should be added to `trailersRemoved_`. + // + // Unfortunately ::unregisterTrailer cannot be allowed to OOM. To get + // around this we rely on the observation that all deregistered blocks + // should previously have been registered, so the deregistered set can never + // be larger than the registered set. Hence ::registerTrailer effectively + // preallocates space in `trailersRemoved_` so as to ensure that, in the + // worst case, all registered blocks can be handed to ::unregisterTrailer + // without needing to resize `trailersRemoved_` in ::unregisterTrailer. + // + // The downside is that most of the space in `trailersRemoved_` is wasted in + // the case where there are few blocks deregistered. This is unfortunate + // but it's hard to see how to avoid it. + // + // At the end of a minor collection, all blocks in the set `trailersAdded_ - + // trailersRemoved_[0 .. trailersRemovedUsed_ - 1]` are handed back to the + // `mallocedBlockCache_`. + [[nodiscard]] inline bool registerTrailer(PointerAndUint7 blockAndListID, + size_t nBytes); + inline void unregisterTrailer(void* block); + size_t sizeOfTrailerBlockSets(mozilla::MallocSizeOf mallocSizeOf) const; + + size_t capacity() const { return capacity_; } + size_t committed() const { + return std::min(capacity_, allocatedChunkCount() * gc::ChunkSize); + } + + // Used and free space both include chunk headers for that part of the + // nursery. + // + // usedSpace() + freeSpace() == capacity() + // + MOZ_ALWAYS_INLINE size_t usedSpace() const { + return capacity() - freeSpace(); + } + MOZ_ALWAYS_INLINE size_t freeSpace() const { + MOZ_ASSERT(isEnabled()); + MOZ_ASSERT(currentEnd_ - position_ <= NurseryChunkUsableSize); + MOZ_ASSERT(currentChunk_ < maxChunkCount()); + return (currentEnd_ - position_) + + (maxChunkCount() - currentChunk_ - 1) * gc::ChunkSize; + } + +#ifdef JS_GC_ZEAL + void enterZealMode(); + void leaveZealMode(); +#endif + + // Write profile time JSON on JSONPrinter. + void renderProfileJSON(JSONPrinter& json) const; + + // Print header line for profile times. + void printProfileHeader(); + + // Print total profile times on shutdown. + void printTotalProfileTimes(); + + void* addressOfPosition() const { return (void**)&position_; } + static constexpr int32_t offsetOfCurrentEndFromPosition() { + return offsetof(Nursery, currentEnd_) - offsetof(Nursery, position_); + } + + void* addressOfNurseryAllocatedSites() { + return pretenuringNursery.addressOfAllocatedSites(); + } + + void requestMinorGC(JS::GCReason reason); + + bool minorGCRequested() const { + return minorGCTriggerReason_ != JS::GCReason::NO_REASON; + } + JS::GCReason minorGCTriggerReason() const { return minorGCTriggerReason_; } + + bool shouldCollect() const; + bool isNearlyFull() const; + bool isUnderused() const; + + bool enableProfiling() const { return enableProfiling_; } + + bool addMapWithNurseryMemory(MapObject* obj) { + MOZ_ASSERT_IF(!mapsWithNurseryMemory_.empty(), + mapsWithNurseryMemory_.back() != obj); + return mapsWithNurseryMemory_.append(obj); + } + bool addSetWithNurseryMemory(SetObject* obj) { + MOZ_ASSERT_IF(!setsWithNurseryMemory_.empty(), + setsWithNurseryMemory_.back() != obj); + return setsWithNurseryMemory_.append(obj); + } + + // The amount of space in the mapped nursery available to allocations. + static const size_t NurseryChunkUsableSize = + gc::ChunkSize - sizeof(gc::ChunkBase); + + void joinDecommitTask(); + + mozilla::TimeStamp collectionStartTime() { + return startTimes_[ProfileKey::Total]; + } + + bool canCreateAllocSite() { return pretenuringNursery.canCreateAllocSite(); } + void noteAllocSiteCreated() { pretenuringNursery.noteAllocSiteCreated(); } + bool reportPretenuring() const { return reportPretenuring_; } + void maybeStopPretenuring(gc::GCRuntime* gc) { + pretenuringNursery.maybeStopPretenuring(gc); + } + + void setAllocFlagsForZone(JS::Zone* zone); + + // Round a size in bytes to the nearest valid nursery size. + static size_t roundSize(size_t size); + + // The malloc'd block cache. + gc::MallocedBlockCache& mallocedBlockCache() { return mallocedBlockCache_; } + size_t sizeOfMallocedBlockCache(mozilla::MallocSizeOf mallocSizeOf) const { + return mallocedBlockCache_.sizeOfExcludingThis(mallocSizeOf); + } + + mozilla::TimeStamp lastCollectionEndTime() const; + + private: + enum class ProfileKey { +#define DEFINE_TIME_KEY(name, text) name, + FOR_EACH_NURSERY_PROFILE_TIME(DEFINE_TIME_KEY) +#undef DEFINE_TIME_KEY + KeyCount + }; + + using ProfileTimes = + mozilla::EnumeratedArray<ProfileKey, ProfileKey::KeyCount, + mozilla::TimeStamp>; + using ProfileDurations = + mozilla::EnumeratedArray<ProfileKey, ProfileKey::KeyCount, + mozilla::TimeDuration>; + + // Calculate the promotion rate of the most recent minor GC. + // The valid_for_tenuring parameter is used to return whether this + // promotion rate is accurate enough (the nursery was full enough) to be + // used for tenuring and other decisions. + // + // Must only be called if the previousGC data is initialised. + double calcPromotionRate(bool* validForTenuring) const; + + void freeTrailerBlocks(); + + NurseryChunk& chunk(unsigned index) const { return *chunks_[index]; } + + // Set the allocation position to the start of a chunk. This sets + // currentChunk_, position_ and currentEnd_ values as appropriate. + void moveToStartOfChunk(unsigned chunkno); + + bool initFirstChunk(AutoLockGCBgAlloc& lock); + + // extent is advisory, it will be ignored in sub-chunk and generational zeal + // modes. It will be clamped to Min(NurseryChunkUsableSize, capacity_). + void poisonAndInitCurrentChunk(size_t extent = gc::ChunkSize); + + void setCurrentEnd(); + void setStartToCurrentPosition(); + + // Allocate the next chunk, or the first chunk for initialization. + // Callers will probably want to call moveToStartOfChunk(0) next. + [[nodiscard]] bool allocateNextChunk(unsigned chunkno, + AutoLockGCBgAlloc& lock); + + uintptr_t currentEnd() const { return currentEnd_; } + + uintptr_t position() const { return position_; } + + MOZ_ALWAYS_INLINE bool isSubChunkMode() const; + + JSRuntime* runtime() const; + gcstats::Statistics& stats() const; + + const js::gc::GCSchedulingTunables& tunables() const; + + void getAllocFlagsForZone(JS::Zone* zone, bool* allocObjectsOut, + bool* allocStringsOut, bool* allocBigIntsOut); + void updateAllZoneAllocFlags(); + void updateAllocFlagsForZone(JS::Zone* zone); + void discardCodeAndSetJitFlagsForZone(JS::Zone* zone); + + void* allocate(size_t size); + + // Common internal allocator function. If this fails, call + // handleAllocationFailure to see whether it's possible to retry. + inline void* tryAllocate(size_t size); + + [[nodiscard]] bool moveToNextChunk(); + + struct CollectionResult { + size_t tenuredBytes; + size_t tenuredCells; + }; + CollectionResult doCollection(gc::AutoGCSession& session, + JS::GCOptions options, JS::GCReason reason); + void traceRoots(gc::AutoGCSession& session, gc::TenuringTracer& mover); + + size_t doPretenuring(JSRuntime* rt, JS::GCReason reason, + bool validPromotionRate, double promotionRate); + + // Handle relocation of slots/elements pointers stored in Ion frames. + inline void setForwardingPointer(void* oldData, void* newData, bool direct); + + inline void setDirectForwardingPointer(void* oldData, void* newData); + void setIndirectForwardingPointer(void* oldData, void* newData); + + inline void setSlotsForwardingPointer(HeapSlot* oldSlots, HeapSlot* newSlots, + uint32_t nslots); + inline void setElementsForwardingPointer(ObjectElements* oldHeader, + ObjectElements* newHeader, + uint32_t capacity); + +#ifdef DEBUG + bool checkForwardingPointerLocation(void* ptr, bool expectedInside); +#endif + + // Updates pointers to nursery objects that have been tenured and discards + // pointers to objects that have been freed. + void sweep(); + + // Reset the current chunk and position after a minor collection. Also poison + // the nursery on debug & nightly builds. + void clear(); + + void sweepMapAndSetObjects(); + + // Allocate a buffer for a given zone, using the nursery if possible. + void* allocateBuffer(JS::Zone* zone, size_t nbytes); + + // Change the allocable space provided by the nursery. + void maybeResizeNursery(JS::GCOptions options, JS::GCReason reason); + size_t targetSize(JS::GCOptions options, JS::GCReason reason); + void clearRecentGrowthData(); + void growAllocableSpace(size_t newCapacity); + void shrinkAllocableSpace(size_t newCapacity); + void minimizeAllocableSpace(); + + // Free the chunks starting at firstFreeChunk until the end of the chunks + // vector. Shrinks the vector but does not update maxChunkCount(). + void freeChunksFrom(unsigned firstFreeChunk); + + void sendTelemetry(JS::GCReason reason, mozilla::TimeDuration totalTime, + bool wasEmpty, double promotionRate, + size_t sitesPretenured); + + void printCollectionProfile(JS::GCReason reason, double promotionRate); + void printDeduplicationData(js::StringStats& prev, js::StringStats& curr); + + // Profile recording and printing. + void maybeClearProfileDurations(); + void startProfile(ProfileKey key); + void endProfile(ProfileKey key); + static void printProfileDurations(const ProfileDurations& times, + Sprinter& sprinter); + + mozilla::TimeStamp collectionStartTime() const; + + private: + // Fields used during allocation fast path are grouped first: + + // Pointer to the first unallocated byte in the nursery. + uintptr_t position_; + + // Pointer to the last byte of space in the current chunk. + uintptr_t currentEnd_; + + // Other fields not necessarily used during allocation follow: + + gc::GCRuntime* const gc; + + // Vector of allocated chunks to allocate from. + Vector<NurseryChunk*, 0, SystemAllocPolicy> chunks_; + + // The index of the chunk that is currently being allocated from. + uint32_t currentChunk_; + + // These fields refer to the beginning of the nursery. They're normally 0 + // and chunk(0).start() respectively. Except when a generational GC zeal + // mode is active, then they may be arbitrary (see Nursery::clear()). + uint32_t startChunk_; + uintptr_t startPosition_; + + // The current nursery capacity measured in bytes. It may grow up to this + // value without a collection, allocating chunks on demand. This limit may be + // changed by maybeResizeNursery() each collection. It includes chunk headers. + size_t capacity_; + + gc::PretenuringNursery pretenuringNursery; + + mozilla::TimeDuration timeInChunkAlloc_; + + // Report minor collections taking at least this long, if enabled. + bool enableProfiling_ = false; + bool profileWorkers_ = false; + + mozilla::TimeDuration profileThreshold_; + + // Whether we will nursery-allocate strings. + bool canAllocateStrings_; + + // Whether we will nursery-allocate BigInts. + bool canAllocateBigInts_; + + // Report how many strings were deduplicated. + bool reportDeduplications_; + + // Whether to report information on pretenuring, and if so the allocation + // threshold at which to report details of each allocation site. + bool reportPretenuring_; + size_t reportPretenuringThreshold_; + + // Whether and why a collection of this nursery has been requested. When this + // happens |prevPosition_| is set to the current position and |position_| set + // to the end of the chunk to force the next allocation to fail. + JS::GCReason minorGCTriggerReason_; + uintptr_t prevPosition_; + + // Profiling data. + + ProfileTimes startTimes_; + ProfileDurations profileDurations_; + ProfileDurations totalDurations_; + + // Data about the previous collection. + struct PreviousGC { + JS::GCReason reason = JS::GCReason::NO_REASON; + size_t nurseryCapacity = 0; + size_t nurseryCommitted = 0; + size_t nurseryUsedBytes = 0; + size_t nurseryUsedChunkCount = 0; + size_t tenuredBytes = 0; + size_t tenuredCells = 0; + mozilla::TimeStamp endTime; + }; + PreviousGC previousGC; + + bool hasRecentGrowthData; + double smoothedTargetSize; + + // The set of externally malloced buffers potentially kept live by objects + // stored in the nursery. Any external buffers that do not belong to a + // tenured thing at the end of a minor GC must be freed. + using BufferRelocationOverlay = void*; + using BufferSet = HashSet<void*, PointerHasher<void*>, SystemAllocPolicy>; + BufferSet mallocedBuffers; + size_t mallocedBufferBytes = 0; + + // Wasm "trailer" (C++-heap-allocated) blocks. See comments above on + // ::registerTrailer and ::unregisterTrailer. + Vector<PointerAndUint7, 0, SystemAllocPolicy> trailersAdded_; + Vector<void*, 0, SystemAllocPolicy> trailersRemoved_; + size_t trailersRemovedUsed_ = 0; + size_t trailerBytes_ = 0; + + // During a collection most hoisted slot and element buffers indicate their + // new location with a forwarding pointer at the base. This does not work + // for buffers whose length is less than pointer width, or when different + // buffers might overlap each other. For these, an entry in the following + // table is used. + using ForwardedBufferMap = + HashMap<void*, void*, PointerHasher<void*>, SystemAllocPolicy>; + ForwardedBufferMap forwardedBuffers; + + // When we assign a unique id to cell in the nursery, that almost always + // means that the cell will be in a hash table, and thus, held live, + // automatically moving the uid from the nursery to its new home in + // tenured. It is possible, if rare, for an object that acquired a uid to + // be dead before the next collection, in which case we need to know to + // remove it when we sweep. + // + // Note: we store the pointers as Cell* here, resulting in an ugly cast in + // sweep. This is because this structure is used to help implement + // stable object hashing and we have to break the cycle somehow. + using CellsWithUniqueIdVector = Vector<gc::Cell*, 8, SystemAllocPolicy>; + CellsWithUniqueIdVector cellsWithUid_; + + // Lists of map and set objects allocated in the nursery or with iterators + // allocated there. Such objects need to be swept after minor GC. + Vector<MapObject*, 0, SystemAllocPolicy> mapsWithNurseryMemory_; + Vector<SetObject*, 0, SystemAllocPolicy> setsWithNurseryMemory_; + + UniquePtr<NurseryDecommitTask> decommitTask; + + // A cache of small C++-heap allocated blocks associated with this Nursery. + // This provided so as to provide cheap allocation/deallocation of + // out-of-line storage areas as used by WasmStructObject and + // WasmArrayObject, although the mechanism is general and not specific to + // these object types. Regarding lifetimes, because the cache holds only + // blocks that are not currently in use, it can be flushed at any point with + // no correctness impact, only a performance impact. + gc::MallocedBlockCache mallocedBlockCache_; + + friend class gc::GCRuntime; + friend class gc::TenuringTracer; + friend struct NurseryChunk; +}; + +} // namespace js + +#endif // gc_Nursery_h |