void Heap::addReference(JSCell* cell, ArrayBuffer* buffer) { if (m_arrayBuffers.addReference(cell, buffer)) { collectIfNecessaryOrDefer(); didAllocate(buffer->gcSizeEstimateInBytes()); } }
void Heap::reportAbandonedObjectGraph() { // Our clients don't know exactly how much memory they // are abandoning so we just guess for them. double abandonedBytes = 0.10 * m_sizeAfterLastCollect; // We want to accelerate the next collection. Because memory has just // been abandoned, the next collection has the potential to // be more profitable. Since allocation is the trigger for collection, // we hasten the next collection by pretending that we've allocated more memory. didAllocate(abandonedBytes); }
void Heap::reportExtraMemoryCostSlowCase(size_t cost) { // Our frequency of garbage collection tries to balance memory use against speed // by collecting based on the number of newly created values. However, for values // that hold on to a great deal of memory that's not in the form of other JS values, // that is not good enough - in some cases a lot of those objects can pile up and // use crazy amounts of memory without a GC happening. So we track these extra // memory costs. Only unusually large objects are noted, and we only keep track // of this extra cost until the next GC. In garbage collected languages, most values // are either very short lived temporaries, or have extremely long lifetimes. So // if a large value survives one garbage collection, there is not much point to // collecting more frequently as long as it stays alive. didAllocate(cost); collectIfNecessaryOrDefer(); }
void Heap::reportExtraMemoryAllocatedSlowCase(size_t size) { didAllocate(size); collectIfNecessaryOrDefer(); }