MMgc::GC Class Reference

#include <GC.h>

Inheritance diagram for MMgc::GC:

List of all members.

Public Types
enum	{ GCV_COREPLAYER, GCV_AVMCORE, GCV_COUNT }
enum	AllocFlags { kZero = 1, kContainsPointers = 2, kFinalize = 4, kRCObject = 8 }
enum	PageType { kNonGC = 0, kGCAllocPage = 1, kGCLargeAllocPageRest = 2, kGCLargeAllocPageFirst = 3 }
Public Member Functions
void *	GetGCContextVariable (int var) const
void	SetGCContextVariable (int var, void *val)
avmplus::AvmCore *	core () const
	GC (GCHeap *heap)
	~GC ()
void	Collect ()
void	MaybeGC (bool callerHasActiveRequest=false)
void *	Alloc (size_t size, int flags=0)
void *	AllocAlreadyLocked (size_t size, int flags=0)
void *	Calloc (size_t num, size_t elsize, int flags=0)
void	Free (const void *ptr)
void	SetQueued (const void *item)
void *	AllocBlock (int size, int pageType, bool zero=true)
void	FreeBlock (void *ptr, uint32 size)
GCHeap *	GetGCHeap () const
bool	IsPointerToGCPage (const void *item)
void	IncrementalMark ()
bool	IncrementalMarking ()
void	writeBarrier (const void *container, const void *address, const void *value)
void	writeBarrierRC (const void *container, const void *address, const void *value)
__forceinline void	WriteBarrierNoSubstitute (const void *container, const void *value)
__forceinline void	WriteBarrierTrap (const void *container, const void *valuePtr)
void	ConservativeWriteBarrierNoSubstitute (const void *address, const void *value)
bool	ContainsPointers (const void *item)
void *	FindBeginning (const void *gcItem)
bool	IsRCObject (const void *)
bool	Collecting () const
bool	IsGCMemory (const void *)
bool	IsQueued (const void *item)
void	DisableThreadCheck ()
void	CleanStack (bool force=false)
bool	Destroying ()
void	ClearWeakRef (const void *obj)
uintptr	GetStackTop () const
void	PushWorkItem (GCWorkItem &item)
void	UpdateStat (const char *key, int delta)
size_t	GetBytesInUse ()
Static Public Member Functions
static size_t	Size (const void *ptr)
static int	GetMark (const void *item)
static int	SetMark (const void *item)
static void	ClearFinalized (const void *item)
static void	SetFinalize (const void *item)
static int	IsFinalized (const void *item)
static int	HasWeakRef (const void *item)
static GC *	GetGC (const void *item)
static void	WriteBarrier (const void *address, const void *value)
static void	WriteBarrierNoSub (const void *address, const void *value)
static uint64	GetPerformanceCounter ()
static uint64	GetPerformanceFrequency ()
static double	duration (uint64 start)
static uint64	ticksToMicros (uint64 ticks)
static uint64	ticksToMillis (uint64 ticks)
static GCWeakRef *	GetWeakRef (const void *obj)
Public Attributes
bool	greedy
bool	nogc
bool	findUnmarkedPointers
bool	validateDefRef
bool	keepDRCHistory
size_t	collectThreshold
bool	gcstats
bool	dontAddToZCTDuringCollection
bool	incrementalValidation
bool	incremental
const uint64	t0
uint64	bytesMarked
uint64	markTicks
uint32	lastStartMarkIncrementCount
uint32	markIncrements
uint32	marks
uint32	sweeps
uint32	numObjects
uint32	objSize
uint64	sweepStart
bool	hitZeroObjects
Protected Member Functions
void	CollectWithBookkeeping (bool callerHoldsLock, bool callerHasActiveRequest)
Private Member Functions
__forceinline void	WriteBarrierWrite (const void *address, const void *value)
__forceinline void	WriteBarrierWriteRC (const void *address, const void *value)
void *	heapAlloc (size_t size, bool expand=true, bool zero=true)
void	heapFree (void *ptr, size_t siz=0)
void	gclog (const char *format,...)
void	log_mem (const char *name, size_t s, size_t comp)
uint32 *	GetBits (int numBytes, int sizeClass)
void	FreeBits (uint32 *bits, int sizeClass)
void	StartIncrementalMark ()
void	FinishIncrementalMark ()
int	IsWhite (const void *item)
void	updateGrossMemoryStats ()
int	GetPageMapValue (uintptr addr) const
int	GetPageMapValueAlreadyLocked (uintptr addr) const
void	SetPageMapValue (uintptr addr, int val)
void	ClearPageMapValue (uintptr addr)
void	MarkGCPages (void *item, uint32 numpages, int val)
void	UnmarkGCPages (void *item, uint32 numpages)
void	ConservativeMarkRegion (const void *base, size_t bytes)
void *	AllocBlockIncremental (int size, bool zero=true)
void *	AllocBlockNonIncremental (int size, bool zero=true)
void	CollectImpl ()
void	ClearMarks ()
void	Finalize ()
void	Sweep (bool force=false)
void	ForceSweep ()
void	Mark (GCStack< GCWorkItem > &work)
void	MarkQueueAndStack (GCStack< GCWorkItem > &work)
void	MarkItem (GCStack< GCWorkItem > &work)
void	MarkItem (GCWorkItem &workitem, GCStack< GCWorkItem > &work)
void	TrapWrite (const void *black, const void *white)
void	AddToSmallEmptyBlockList (GCAlloc::GCBlock *b)
void	AddToLargeEmptyBlockList (GCLargeAlloc::LargeBlock *lb)
void	AddRoot (GCRoot *root)
void	RemoveRoot (GCRoot *root)
void	AddCallback (GCCallback *cb)
void	RemoveCallback (GCCallback *cb)
void	CheckThread ()
void	PushWorkItem (GCStack< GCWorkItem > &stack, GCWorkItem item)
Static Private Member Functions
static const void *	Pointer (const void *p)
Private Attributes
uint32 *	m_bitsFreelists [kNumSizeClasses]
uint32 *	m_bitsNext
GCHashtable	weakRefs
bool	destroying
size_t	heapSizeAtLastAlloc
bool	stackCleaned
const void *	rememberedStackTop
const void *	rememberedStackBottom
bool	disableThreadCheck
bool	marking
GCStack< GCWorkItem >	m_incrementalWork
uint64	lastMarkTicks
uint64	lastSweepTicks
void *	m_contextVars [GCV_COUNT]
uintptr	memStart
uintptr	memEnd
size_t	totalGCPages
GCHashtable	stats
unsigned char *	pageMap
GCAlloc *	containsPointersAllocs [kNumSizeClasses]
GCAlloc *	noPointersAllocs [kNumSizeClasses]
GCLargeAlloc *	largeAlloc
GCHeap *	heap
unsigned int	allocsSinceCollect
bool	collecting
bool	finalizedValue
GCAlloc::GCBlock *	smallEmptyPageList
GCLargeAlloc::LargeBlock *	largeEmptyPageList
GCRoot *	m_roots
GCCallback *	m_callbacks
Static Private Attributes
static const int	kNumSizeClasses = 40
static const int	kPageUsableSpace = 3936
static const int16	kSizeClasses [kNumSizeClasses]
static const uint8	kSizeClassIndex [246]
Friends
class	GCRoot
class	GCCallback
class	GCAlloc
class	GCLargeAlloc
class	RCObject
class	GCInterval
class	ZCT

---

Detailed Description

This is a general-purpose garbage collector used by the Flash Player. Application code must implement the GCRoot interface to mark all reachable data. Unreachable data is automatically destroyed. Objects may optionally be finalized by subclassing the GCObject interface.

This garbage collector is intended to be modular, such that it can be used in other products or replaced with a different collector in the future.

Memory allocation and garbage collection strategy: Mark and sweep garbage collector using fixed size classes implemented by the GCAlloc class. Memory blocks are obtained from the OS via the GCHeap heap manager class.

When an allocation fails because a suitable memory block is not available, the garbage collector decides either to garbage collect to free up space, or to expand the heap. The heuristic used to make the decision to collect or expand is taken from the Boehm-Demers-Weiser (BDW) garbage collector and memory allocator. The BDW algorithm is (pseudo-code):

if (allocs since collect >= heap size / FSD) collect else expand(request size + heap size / FSD)

The FSD is the "Free Space Divisor." For the first cut, I'm trying 4. TODO: Try various FSD values against real Player workloads to find the optimum value.

Definition at line 545 of file GC.h.

---

Member Enumeration Documentation

anonymous enum

If you need context vars use this! Enumerator: GCV_COREPLAYER  GCV_AVMCORE  GCV_COUNT  Definition at line 559 of file GC.h. { GCV_COREPLAYER, GCV_AVMCORE, GCV_COUNT };

enum MMgc::GC::AllocFlags

flags to be passed as second argument to alloc Enumerator: kZero  kContainsPointers  kFinalize  kRCObject  Definition at line 676 of file GC.h. { kZero=1, kContainsPointers=2, kFinalize=4, kRCObject=8 };

enum MMgc::GC::PageType

Enumerator: kNonGC  kGCAllocPage  kGCLargeAllocPageRest  kGCLargeAllocPageFirst  Definition at line 684 of file GC.h. { kNonGC = 0, kGCAllocPage = 1, kGCLargeAllocPageRest = 2, kGCLargeAllocPageFirst = 3 };

---

Constructor & Destructor Documentation

MMgc::GC::GC (  GCHeap *  heap  )

Definition at line 229 of file GC.cpp. References MMgc::GCWorkItem::_size, containsPointersAllocs, GCAlloc, util::threadpool::i, kNumSizeClasses, kSizeClasses, MMGC_STATIC_ASSERT, noPointersAllocs, MMgc::GCWorkItem::ptr, and rememberedStackBottom. : #ifdef MMGC_DRC zct(), #endif nogc(false), greedy(false), findUnmarkedPointers(false), validateDefRef(false), keepDRCHistory(false), gcstats(false), #ifdef WRITE_BARRIERS incremental(true), #else incremental(false), #endif incrementalValidation(false), #ifdef _DEBUG // check for missing write barriers at every Alloc incrementalValidationPedantic(false), #endif marking(false), memStart(MAX_UINTPTR), memEnd(0), heap(gcheap), allocsSinceCollect(0), collecting(false), m_roots(0), m_callbacks(0), markTicks(0), bytesMarked(0), markIncrements(0), marks(0), sweeps(0), totalGCPages(0), stackCleaned(true), rememberedStackTop(0), destroying(false), lastMarkTicks(0), lastSweepTicks(0), lastStartMarkIncrementCount(0), t0(GetPerformanceCounter()), dontAddToZCTDuringCollection(false), numObjects(0), hitZeroObjects(false), smallEmptyPageList(NULL), largeEmptyPageList(NULL), sweepStart(0), heapSizeAtLastAlloc(gcheap->GetTotalHeapSize()), finalizedValue(true), // Expand, don't collect, until we hit this threshold collectThreshold(256), #if MMGC_THREADSAFE m_exclusiveGCThread(NULL), m_gcRunning(false), m_condDone(m_lock), m_requestCount(0), m_condNoRequests(m_lock) #else disableThreadCheck(false) #endif { // sanity check for all our types MMGC_STATIC_ASSERT(sizeof(int8) == 1); MMGC_STATIC_ASSERT(sizeof(uint8) == 1); MMGC_STATIC_ASSERT(sizeof(int16) == 2); MMGC_STATIC_ASSERT(sizeof(uint16) == 2); MMGC_STATIC_ASSERT(sizeof(int32) == 4); MMGC_STATIC_ASSERT(sizeof(uint32) == 4); MMGC_STATIC_ASSERT(sizeof(int64) == 8); MMGC_STATIC_ASSERT(sizeof(uint64) == 8); MMGC_STATIC_ASSERT(sizeof(sintptr) == sizeof(void *)); MMGC_STATIC_ASSERT(sizeof(uintptr) == sizeof(void *)); #ifdef MMGC_64BIT MMGC_STATIC_ASSERT(sizeof(sintptr) == 8); MMGC_STATIC_ASSERT(sizeof(uintptr) == 8); #else MMGC_STATIC_ASSERT(sizeof(sintptr) == 4); MMGC_STATIC_ASSERT(sizeof(uintptr) == 4); #endif { GCWorkItem item; MMGC_GET_STACK_EXTENTS(this, item.ptr, item._size); rememberedStackBottom = (const void *)((const char *)item.ptr + item._size); } #ifdef MMGC_DRC zct.SetGC(this); #endif // Create all the allocators up front (not lazy) // so that we don't have to check the pointers for // NULL on every allocation. for (int i=0; i<kNumSizeClasses; i++) { containsPointersAllocs[i] = new GCAlloc(this, kSizeClasses[i], true, false, i); #ifdef MMGC_DRC containsPointersRCAllocs[i] = new GCAlloc(this, kSizeClasses[i], true, true, i); #endif noPointersAllocs[i] = new GCAlloc(this, kSizeClasses[i], false, false, i); } largeAlloc = new GCLargeAlloc(this); pageMap = (unsigned char*) heapAlloc(1); memset(m_bitsFreelists, 0, sizeof(uint32*) * kNumSizeClasses); m_bitsNext = (uint32*)heapAlloc(1); // precondition for emptyPageList GCAssert(offsetof(GCLargeAlloc::LargeBlock, next) == offsetof(GCAlloc::GCBlock, next)); for(int i=0; i<GCV_COUNT; i++) { SetGCContextVariable(i, NULL); } #ifdef _DEBUG // this doens't hurt performance too much so alway leave it on in DEBUG builds // before sweeping we check for missing write barriers incrementalValidation = true; #ifdef WIN32 m_gcThread = GetCurrentThreadId(); #endif #endif // keep GC::Size honest GCAssert(offsetof(GCLargeAlloc::LargeBlock, usableSize) == offsetof(GCAlloc::GCBlock, size)); #ifndef MMGC_PORTING_API #ifndef MMGC_ARM // TODO MMGC_ARM #ifdef _DEBUG if (!nogc) RunGCTests(this); #endif #endif #endif // keep GC::Size honest GCAssert(offsetof(GCLargeAlloc::LargeBlock, usableSize) == offsetof(GCAlloc::GCBlock, size)); }

MMgc::GC::~GC (   )

Definition at line 373 of file GC.cpp. References ClearMarks(), destroying, ForceSweep(), util::threadpool::i, kNumSizeClasses, m_bitsFreelists, next, and NULL. { // Force all objects to be destroyed destroying = true; ClearMarks(); ForceSweep(); // Go through m_bitsFreelist and collect list of all pointers // that are on page boundaries into new list, pageList void **pageList = NULL; for(int i=0, n=kNumSizeClasses; i<n; i++) { uint32* bitsFreelist = m_bitsFreelists[i]; while(bitsFreelist) { uint32 *next = *(uint32**)bitsFreelist; if(((uintptr)bitsFreelist & 0xfff) == 0) { *((void**)bitsFreelist) = pageList; pageList = (void**)bitsFreelist; } bitsFreelist = next; } } // Go through page list and free all pages on it while (pageList) { void **next = (void**) *pageList; heap->Free((void*)pageList); pageList = next; } for (int i=0; i < kNumSizeClasses; i++) { delete containsPointersAllocs[i]; #ifdef MMGC_DRC delete containsPointersRCAllocs[i]; #endif delete noPointersAllocs[i]; } if (largeAlloc) { delete largeAlloc; } // dtors for each GCAlloc will use this pageList = NULL; heap->Free(pageMap); #ifndef MMGC_THREADSAFE CheckThread(); #endif GCAssert(!m_roots); GCAssert(!m_callbacks); { GCSpinLock lock(m_rootListLock); // apparently the player can't be made to clean up so keep it from crashing at least while(m_roots) { m_roots->Destroy(); } } while(m_callbacks) { m_callbacks->Destroy(); } }

---

Member Function Documentation

void MMgc::GC::AddCallback (  GCCallback *  cb  )  [private]

Definition at line 3146 of file GC.cpp. References m_callbacks, MMgc::GCCallback::nextCB, NULL, MMgc::GCCallback::prevCB, and USING_CALLBACK_LIST. Referenced by MMgc::GCCallback::GCCallback(). { USING_CALLBACK_LIST(this); cb->prevCB = NULL; cb->nextCB = m_callbacks; if(m_callbacks) m_callbacks->prevCB = cb; m_callbacks = cb; }

void MMgc::GC::AddRoot (  GCRoot *  root  )  [private]

Definition at line 3120 of file GC.cpp. References m_roots, MMgc::GCRoot::next, NULL, and MMgc::GCRoot::prev. Referenced by MMgc::GCRoot::init(). { #ifdef GCHEAP_LOCK GCAcquireSpinlock lock(m_rootListLock); #endif root->prev = NULL; root->next = m_roots; if(m_roots) m_roots->prev = root; m_roots = root; }

void MMgc::GC::AddToLargeEmptyBlockList (  GCLargeAlloc::LargeBlock *  lb  )  [inline, private]

Requires(exclusiveGC) Definition at line 1412 of file GC.h. References MMgc::GCLargeAlloc::LargeBlock::next. Referenced by MMgc::GCLargeAlloc::Finalize(). { lb->next = largeEmptyPageList; largeEmptyPageList = lb; }

void MMgc::GC::AddToSmallEmptyBlockList (  GCAlloc::GCBlock *  b  )  [inline, private]

Requires(exclusiveGC) Definition at line 1399 of file GC.h. References MMgc::GCAlloc::GCBlock::next. { b->next = smallEmptyPageList; smallEmptyPageList = b; }

void * MMgc::GC::Alloc (  size_t  size, int  flags = 0 )

Main interface for allocating memory. Default flags is no finalization, contains pointers is set and zero is set. Do not call this from a finalizer. Requires(request) Definition at line 655 of file GC.cpp. References AllocAlreadyLocked(), CheckThread(), and GCAssert. Referenced by avmplus::AvmCore::allocDouble(), Calloc(), avmplus::Toplevel::decode(), avmplus::MethodEnv::delegateInvoke(), avmplus::BitSet::grow(), avmplus::MultinameHashtable::Init(), avmplus::Hashtable::initialize(), avmplus::Traits::initTables(), avmplus::interp(), main(), MMgc::GCWeakRef::operator new(), MMgc::GCObject::operator new(), operator new(), MMgc::GCFinalizedObjectOptIn::operator new(), MMgc::GCFinalizedObject::operator new(), avmplus::BasicScriptBufferImpl::operator new(), avmplus::ArrayClass::sortOn(), avmplus::String::String(), avmplus::StringNullTerminatedUTF8::StringNullTerminatedUTF8(), avmplus::StringOutputStream::StringOutputStream(), avmplus::MethodInfo::verifyEnter(), and avmplus::StringOutputStream::write(). { #ifdef MMGC_THREADSAFE GCAutoLock _lock(m_lock); GCAssert(!m_gcRunning); #else CheckThread(); #endif return AllocAlreadyLocked(size, flags); }

void * MMgc::GC::AllocAlreadyLocked (  size_t  size, int  flags = 0 )

Requires(request && m_lock) Definition at line 666 of file GC.cpp. References MMgc::GCLargeAlloc::Alloc(), MMgc::GCAlloc::Alloc(), CollectWithBookkeeping(), containsPointersAllocs, core(), DebugSize, GCAssert, GCAssertMsg, GCV_AVMCORE, GetGCContextVariable(), GetUserPointer, greedy, kContainsPointers, MMgc::kLargestAlloc, kRCObject, kSizeClassIndex, kZero, largeAlloc, marking, noPointersAllocs, NULL, SAMPLE_ALLOC, Size(), and StartIncrementalMark(). Referenced by Alloc(), and MMgc::GCWeakRef::operator new(). { #ifdef FEATURE_SAMPLER avmplus::AvmCore *core = (avmplus::AvmCore*)GetGCContextVariable(GCV_AVMCORE); if(core) core->sampleCheck(); #endif GCAssertMsg(size > 0, "cannot allocate a 0 sized block\n"); #ifdef _DEBUG GCAssert(size + 7 > size); if (GC::greedy) { CollectWithBookkeeping(true, true); } // always be marking in pedantic mode if(incrementalValidationPedantic) { if(!marking) StartIncrementalMark(); } #endif // overflow detection if(size+7 < size) return NULL; size = (size+7)&~7; // round up to multiple of 8 size += DebugSize(); GCAssertMsg(size > 0, "debug overflow, adding space for Debug stuff overflowed size_t\n"); GCAlloc **allocs = noPointersAllocs; #ifdef MMGC_DRC if(flags & kRCObject) { allocs = containsPointersRCAllocs; } else #endif if(flags & kContainsPointers) { allocs = containsPointersAllocs; } void *item; // Buckets up to 128 are spaced evenly at 8 bytes. if (size <= 128) { GCAlloc *b = (GCAlloc*)allocs[(size >> 3) - 1]; GCAssert(size <= b->GetItemSize()); item = b->Alloc(size, flags); } else if (size <= kLargestAlloc) { // This is the fast lookup table implementation to // find the right allocator. unsigned index = kSizeClassIndex[(size>>3)-1]; // assert that I fit GCAssert(size <= allocs[index]->GetItemSize()); // assert that I don't fit (makes sure we don't waste space) GCAssert(size > allocs[index-1]->GetItemSize()); item = allocs[index]->Alloc(size, flags); } else { item = largeAlloc->Alloc(size, flags); } #ifdef MEMORY_INFO if(item) item = DebugDecorate(item, GC::Size(GetUserPointer(item)) + DebugSize(), 3); #endif #ifdef _DEBUG bool shouldZero = (flags & kZero) || incrementalValidationPedantic; // in debug mode memory is poisoned so we have to clear it here // in release builds memory is zero'd to start and on free/sweep // in pedantic mode uninitialized data can trip the write barrier // detector, only do it for pedantic because otherwise we want the // mutator to get the poisoned data so it crashes if it relies on // uninitialized values if((item) && (shouldZero)) { memset(item, 0, Size(item)); } #endif SAMPLE_ALLOC(item, GC::Size(item)); return item; }

void * MMgc::GC::AllocBlock (  int  size, int  pageType, bool  zero = true )

Used by sub-allocators to obtain memory. Requires(m_lock) Definition at line 1046 of file GC.cpp. References MMgc::GCHeap::Alloc(), AllocBlockIncremental(), AllocBlockNonIncremental(), allocsSinceCollect, collecting, collectThreshold, CollectWithBookkeeping(), MMgc::GCHeap::ExpandHeap(), GCAssert, GetPerformanceCounter(), MMgc::GCHeap::GetTotalHeapSize(), heap, heapSizeAtLastAlloc, incremental, MMgc::GCHeap::kBlockSize, MMgc::kFreeSpaceDivisor, kGCLargeAllocPageFirst, kGCLargeAllocPageRest, MMgc::kMarkSweepBurstTicks, MMgc::kMaxIncrement, lastSweepTicks, MarkGCPages(), marking, MMGC_ASSERT_GC_LOCK, nogc, runtests::now, NULL, StartIncrementalMark(), and totalGCPages. Referenced by MMgc::GCLargeAlloc::Alloc(), and MMgc::GCAlloc::CreateChunk(). { MMGC_ASSERT_GC_LOCK(this); #ifdef DEBUGGER AllocActivity(size); #endif GCAssert(size > 0); // perform gc if heap expanded due to fixed memory allocations // utilize burst logic to prevent this from happening back to back // this logic is here to apply to incremental and non-incremental uint64 now = GetPerformanceCounter(); if(!marking && !collecting && heapSizeAtLastAlloc > collectThreshold && now - lastSweepTicks > kMarkSweepBurstTicks && heapSizeAtLastAlloc < heap->GetTotalHeapSize()) { if(incremental && !nogc) StartIncrementalMark(); else CollectWithBookkeeping(true, true); } void *item; if(incremental && !nogc) item = AllocBlockIncremental(size, zero); else item = AllocBlockNonIncremental(size, zero); if(!item) { int incr = (int)(size + totalGCPages / kFreeSpaceDivisor); if(incr > kMaxIncrement) { incr = size < kMaxIncrement ? kMaxIncrement : size; } heap->ExpandHeap(incr); item = heap->Alloc(size, false); } GCAssert(item != NULL); if (item != NULL) { allocsSinceCollect += size; // mark GC pages in page map, small pages get marked one, // the first page of large pages is 3 and the rest are 2 MarkGCPages(item, 1, pageType); if(pageType == kGCLargeAllocPageFirst) { MarkGCPages((char*)item+GCHeap::kBlockSize, size - 1, kGCLargeAllocPageRest); } totalGCPages += size; } // do this after any heap expansions from GC heapSizeAtLastAlloc = heap->GetTotalHeapSize(); return item; }

void * MMgc::GC::AllocBlockIncremental (  int  size, bool  zero = true )  [private]

Requires(m_lock) Definition at line 1105 of file GC.cpp. References MMgc::GCHeap::Alloc(), allocsSinceCollect, collecting, collectThreshold, FinishIncrementalMark(), GCAssert, GetPerformanceCounter(), heap, IncrementalMark(), incrementalValidation, MMgc::kFreeSpaceDivisor, MMgc::kIncrementalMarkDelayTicks, MMgc::kMarkSweepBurstTicks, lastMarkTicks, lastSweepTicks, marking, MMGC_ASSERT_GC_LOCK, nogc, runtests::now, StartIncrementalMark(), and totalGCPages. Referenced by AllocBlock(). { MMGC_ASSERT_GC_LOCK(this); if(!collecting || incrementalValidation) { uint64 now = GetPerformanceCounter(); if (marking) { if(now - lastMarkTicks > kIncrementalMarkDelayTicks) { IncrementalMark(); } } else if (incrementalValidation || (totalGCPages > collectThreshold && allocsSinceCollect * kFreeSpaceDivisor >= totalGCPages && // burst detection (now - lastSweepTicks > kMarkSweepBurstTicks))) { StartIncrementalMark(); } } void *item = heap->Alloc(size, false, zero); if(!item && !collecting) { if(marking) { GCAssert(!nogc); FinishIncrementalMark(); item = heap->Alloc(size, false, zero); } } return item; }

void * MMgc::GC::AllocBlockNonIncremental (  int  size, bool  zero = true )  [private]

Requires(m_lock) Definition at line 1135 of file GC.cpp. References MMgc::GCHeap::Alloc(), allocsSinceCollect, collectThreshold, CollectWithBookkeeping(), MMgc::GCHeap::GetTotalHeapSize(), heap, MMgc::kFreeSpaceDivisor, MMGC_ASSERT_GC_LOCK, and totalGCPages. Referenced by AllocBlock(). { MMGC_ASSERT_GC_LOCK(this); void *item = heap->Alloc(size, false, zero); if (!item) { if (heap->GetTotalHeapSize() >= collectThreshold && allocsSinceCollect >= totalGCPages / kFreeSpaceDivisor) { CollectWithBookkeeping(true, true); item = heap->Alloc(size, false, zero); } } return item; }

void * MMgc::GC::Calloc (  size_t  num, size_t  elsize, int  flags = 0 )

overflow checking way to call Alloc for a # of n size'd items, all instance of Alloc(num*sizeof(thing)) should be replaced with: Calloc(num, sizeof(thing)) Do not call this from a finalizer. Requires(request) Definition at line 789 of file GC.cpp. References Alloc(), GCAssertMsg, and NULL. Referenced by avmplus::AtomArray::AtomArray(), avmplus::AtomArray::checkCapacity(), avmplus::SortedIntMap< FrameState * >::ensureCapacity(), avmplus::MultinameHashtable::grow(), avmplus::Hashtable::grow(), avmplus::AbstractFunction::initDefaultValues(), avmplus::Traits::initMetadataTable(), avmplus::AbstractFunction::initParamTypes(), avmplus::AbcParser::parseMetadataInfos(), and avmshell::ShellToplevel::ShellToplevel(). { uint64 size = (uint64)num * (uint64)elsize; if(size > 0xfffffff0) { GCAssertMsg(false, "Attempted allocation overflows size_t\n"); return NULL; } return Alloc(num * elsize, flags); }

void MMgc::GC::CheckThread (   )  [private]

Definition at line 1424 of file GC.cpp. References disableThreadCheck, and GCAssertMsg. Referenced by Alloc(), CollectWithBookkeeping(), and Free(). { #ifdef _DEBUG #ifdef WIN32 GCAssertMsg(disableThreadCheck || m_gcThread == GetCurrentThreadId(), "Unsafe access to GC from wrong thread!"); #endif #endif }

void MMgc::GC::CleanStack (  bool  force = false  )

Definition at line 1279 of file GC.cpp. References rememberedStackBottom, rememberedStackTop, and stackCleaned. { #if defined(_MSC_VER) && (defined(_DEBUG) || defined(_ARM_)) // debug builds poison the stack already (void)force; return; #else if(!force && (stackCleaned || rememberedStackTop == 0)) return; stackCleaned = true; register void *stackP; #if defined MMGC_IA32 #ifdef WIN32 __asm { mov stackP,esp } #elif defined SOLARIS stackP = (void *) _getsp(); #else asm("movl %%esp,%0" : "=r" (stackP)); #endif #endif #if defined MMGC_AMD64 #ifdef WIN32 int foo; stackP = &foo; #else asm("mov %%rsp,%0" : "=r" (stackP)); #endif #endif #if defined MMGC_SPARC stackP = (void *) _getsp(); #endif #if defined MMGC_PPC // save off sp #ifdef _MAC asm("mr %0,r1" : "=r" (stackP)); #else // _MAC asm("mr %0,%%r1" : "=r" (stackP)); #endif // _MAC #endif // MMGC_PPC if( ((char*) stackP > (char*)rememberedStackTop) && ((char *)rememberedStackBottom > (char*)stackP)) { size_t amount = (char*) stackP - (char*)rememberedStackTop; void *stack = alloca(amount); if(stack) { memset(stack, 0, amount); } } #endif // __MSC_VER && _DEBUG }

static void MMgc::GC::ClearFinalized (  const void *  item  )  [inline, static]

Definition at line 776 of file GC.h. References MMgc::GCAlloc::ClearFinalized(), MMgc::GCLargeAlloc::ClearFinalized(), GCAssert, GetRealPointer, MMgc::GCLargeAlloc::IsLargeBlock(), and IsPointerToGCPage(). Referenced by Free(). { #ifdef MEMORY_INFO GC *gc = GetGC(item); item = GetRealPointer(item); GCAssert(gc->IsPointerToGCPage(item)); #endif if (GCLargeAlloc::IsLargeBlock(item)) { GCLargeAlloc::ClearFinalized(item); } else { GCAlloc::ClearFinalized(item); } }

void MMgc::GC::ClearMarks (   )  [private]

Requires(exclusiveGC) Definition at line 875 of file GC.cpp. References MMgc::GCAlloc::ClearMarks(), containsPointersAllocs, util::threadpool::i, kNumSizeClasses, MMGC_ASSERT_EXCLUSIVE_GC, MMGC_DRC, and noPointersAllocs. Referenced by ~GC(). { MMGC_ASSERT_EXCLUSIVE_GC(this); for (int i=0; i < kNumSizeClasses; i++) { #ifdef MMGC_DRC containsPointersRCAllocs[i]->ClearMarks(); #endif containsPointersAllocs[i]->ClearMarks(); noPointersAllocs[i]->ClearMarks(); } largeAlloc->ClearMarks(); }

void MMgc::GC::ClearPageMapValue (  uintptr  addr  )  [private]

Zero out the pageMap bits for the given address. Requires(pageMapLock) Definition at line 1197 of file GC.cpp. References GCAssert, MMgc::GCHeap::kBlockSize, memStart, and pageMap. Referenced by UnmarkGCPages(). { uintptr index = (addr-memStart) >> 12; #ifdef MMGC_AMD64 GCAssert((index >> 2) < uintptr(64*65536) * uintptr(GCHeap::kBlockSize)); #else GCAssert((index >> 2) < 64 * GCHeap::kBlockSize); #endif pageMap[index >> 2] &= ~(3<<((index&0x3)*2)); }

void MMgc::GC::ClearWeakRef (  const void *  obj  )

Requires((request && m_lock) || exclusiveGC) Definition at line 3204 of file GC.cpp. References GCAssert, MMgc::GCWeakRef::get(), MMgc::GCHashtable::get(), GetRealPointer, MMgc::GCLargeAlloc::IsLargeBlock(), MMgc::GCWeakRef::m_obj, NULL, MMgc::GCHashtable::remove(), MMgc::GCAlloc::SetHasWeakRef(), MMgc::GCLargeAlloc::SetHasWeakRef(), and weakRefs. Referenced by MMgc::GCLargeAlloc::Finalize(), MMgc::GCLargeAlloc::Free(), MMgc::GCAlloc::Free(), Free(), and MMgc::GCWeakRef::~GCWeakRef(). { GCWeakRef *ref = (GCWeakRef*) weakRefs.remove(item); GCAssert(weakRefs.get(item) == NULL); GCAssert(ref != NULL); GCAssert(ref->get() == item || ref->get() == NULL); if(ref) { ref->m_obj = NULL; item = GetRealPointer(item); if (GCLargeAlloc::IsLargeBlock(item)) { GCLargeAlloc::SetHasWeakRef(item, false); } else { GCAlloc::SetHasWeakRef(item, false); } } }

void MMgc::GC::Collect (   )

Causes an immediate garbage collection. In an MMGC_THREADSAFE build, the caller must not be inside a request. If the caller is inside a request, call CollectFromRequest() instead. Requires(!m_lock && !request) Definition at line 439 of file GC.cpp. References CollectWithBookkeeping(). { CollectWithBookkeeping(false, false); }

void MMgc::GC::CollectImpl (   )  [private]

Just collect. Requires(exclusiveGC) Definition at line 594 of file GC.cpp. References FinishIncrementalMark(), marking, and StartIncrementalMark(). Referenced by CollectWithBookkeeping(). { #ifndef MMGC_THREADSAFE ReapZCT(); #endif if(!marking) StartIncrementalMark(); if(marking) FinishIncrementalMark(); #ifdef _DEBUG // Dumping the stack trace at GC time can be very helpful with stack walk bugs // where something was created, stored away in untraced, unmanaged memory and not // reachable by the conservative stack walk //DumpStackTrace(); FindUnmarkedPointers(); #endif }

bool MMgc::GC::Collecting (   )  const [inline]

True during Sweep phase. Application code can use this to determine if it's being called (directly or indirectly) from a finalizer. See also: IsGCRunning() Requires(request || exclusiveGC) Definition at line 1002 of file GC.h. { return collecting; }

void MMgc::GC::CollectWithBookkeeping (  bool  callerHoldsLock, bool  callerHasActiveRequest )  [protected]

Collect in a thread-safe, recursion-preventing way, with callbacks. Both parameters are ignored in non-MMGC_THREADSAFE builds. In an MMGC_THREADSAFE build, callerHoldsLock must be true iff the calling thread already holds m_lock, and callerHasActiveRequest must be true iff the calling thread is already in an active request. Definition at line 444 of file GC.cpp. References CheckThread(), CollectImpl(), collecting, GCAssert, GCRoot, m_callbacks, MMgc::GCCallback::nextCB, nogc, NULL, and USING_CALLBACK_LIST. Referenced by AllocAlreadyLocked(), AllocBlock(), AllocBlockNonIncremental(), Collect(), and MaybeGC(). { #ifdef MMGC_THREADSAFE GCAssert(callerHoldsLock == m_lock.IsHeld()); #ifdef _DEBUG GCAssert(callerHasActiveRequest == GCThread::GetCurrentThread()->IsInActiveRequest()); #endif #else (void) callerHoldsLock; (void) callerHasActiveRequest; CheckThread(); #endif #ifdef MMGC_THREADSAFE if (!callerHoldsLock) m_lock.Acquire(); if (nogc || m_gcRunning || zct.reaping) { if (!callerHoldsLock) m_lock.Release(); return; } #else if (nogc || collecting || zct.reaping) { return; } #endif #ifdef MMGC_THREADSAFE GCThread *thisThread = GCThread::GetCurrentThread(); if (m_exclusiveGCThread != NULL) { // Someone is already collecting or waiting to collect. // // If it's the current thread, then we're being called // recursively. This maybe shouldn't happen, but Collect can be // called indirectly from a finalizer. Don't recurse, just ignore // it. // // If it's some other thread, wait for that thread to finish. // if (m_exclusiveGCThread != thisThread) { GCRoot *stackRoot; void *stack; size_t stackSize; // Call this macro here, not under "if // (callerHasActiveRequest)", because it introduces local // variables that must survive for the whole lifetime of // stackRoot. MMGC_GET_STACK_EXTENTS(this, stack, stackSize); // Before waiting, this thread must suspend any active // requests. This avoids a deadlock where m_exclusiveGCThread // is waiting for m_requestCount to go to zero while we're // waiting for m_exclusiveGCThread to be done. // // When we do this, we root the calling thread's stack; this // way each collection scans the stack of every thread that is // in a suspended request. // if (callerHasActiveRequest) { stackRoot = new GCRoot(this, stack, stackSize); OnLeaveRequestAlreadyLocked(); } while (m_exclusiveGCThread != NULL) m_condDone.Wait(); if (callerHasActiveRequest) { // Resume previously suspended request. delete stackRoot; OnEnterRequestAlreadyLocked(); } } if (!callerHoldsLock) m_lock.Release(); return; } // If we get here, this thread will collect. m_exclusiveGCThread = thisThread; if (callerHasActiveRequest) { // We must suspend any active requests on this thread. OnLeaveRequestAlreadyLocked(); } // Wait for other threads to suspend or end their active requests, // if any. while (m_requestCount > 0) m_condNoRequests.Wait(); // These should not have changed while we were waiting, even though we // released the lock. GCAssert(m_requestCount == 0); GCAssert(m_exclusiveGCThread == thisThread); // This thread has acquired exclusiveGC. m_gcRunning = true; #endif { USING_CALLBACK_LIST(this); for (GCCallback *cb = m_callbacks; cb; cb = cb->nextCB) cb->enterExclusiveGC(); } #ifdef MMGC_THREADSAFE m_lock.Release(); #endif { USING_CALLBACK_LIST(this); for (GCCallback *cb = m_callbacks; cb; cb = cb->nextCB) cb->enterExclusiveGCNoLock(); } CollectImpl(); #ifdef MMGC_THREADSAFE m_lock.Acquire(); // These should not have changed during collection, // even though we released the lock. GCAssert(m_requestCount == 0); GCAssert(m_exclusiveGCThread == thisThread); #endif { USING_CALLBACK_LIST(this); for (GCCallback *cb = m_callbacks; cb; cb = cb->nextCB) cb->leaveExclusiveGC(); } #ifdef MMGC_THREADSAFE // This thread is relinquishing exclusiveGC. m_gcRunning = false; m_exclusiveGCThread = NULL; if (callerHasActiveRequest) OnEnterRequestAlreadyLocked(); m_condDone.NotifyAll(); if (!callerHoldsLock) m_lock.Release(); #endif }

void MMgc::GC::ConservativeMarkRegion (  const void *  base, size_t  bytes )  [private]

Mark a region of memory, this will search all memory pointed to recursively and mark any GC Objects it finds

void MMgc::GC::ConservativeWriteBarrierNoSubstitute (  const void *  address, const void *  value )  [inline]

Definition at line 939 of file GC.h. { if(IsPointerToGCPage(address)) WriteBarrierNoSubstitute(FindBeginning(address), value); }

bool MMgc::GC::ContainsPointers (  const void *  item  )

Requires(request || exclusiveGC) Definition at line 3051 of file GC.cpp. References MMgc::GCAlloc::ContainsPointers(), MMgc::GCLargeAlloc::ContainsPointers(), GetRealPointer, and MMgc::GCLargeAlloc::IsLargeBlock(). Referenced by TrapWrite(). { item = GetRealPointer(item); if (GCLargeAlloc::IsLargeBlock(item)) { return GCLargeAlloc::ContainsPointers(item); } else { return GCAlloc::ContainsPointers(item); } }

avmplus::AvmCore* MMgc::GC::core (   )  const [inline]

Definition at line 568 of file GC.h. Referenced by AllocAlreadyLocked(), IncrementalMark(), and Sweep(). { return (avmplus::AvmCore*)GetGCContextVariable(GCV_AVMCORE); }

bool MMgc::GC::Destroying (   )  [inline]

Definition at line 1120 of file GC.h. { return destroying; }

void MMgc::GC::DisableThreadCheck (   )  [inline]

Definition at line 1022 of file GC.h. { disableThreadCheck = true; }

static double MMgc::GC::duration (  uint64  start  )  [inline, static]

Definition at line 1016 of file GC.h. References GetPerformanceCounter(), and GetPerformanceFrequency(). Referenced by Sweep(). { return (double(GC::GetPerformanceCounter() - start) * 1000) / GC::GetPerformanceFrequency(); }

void MMgc::GC::Finalize (   )  [private]

Requires(exclusiveGC) Definition at line 889 of file GC.cpp. References containsPointersAllocs, MMgc::GCAlloc::Finalize(), util::threadpool::i, kNumSizeClasses, MMGC_ASSERT_EXCLUSIVE_GC, MMGC_DRC, and noPointersAllocs. Referenced by Sweep(). { MMGC_ASSERT_EXCLUSIVE_GC(this); for(int i=0; i < kNumSizeClasses; i++) { #ifdef MMGC_DRC containsPointersRCAllocs[i]->Finalize(); #endif containsPointersAllocs[i]->Finalize(); noPointersAllocs[i]->Finalize(); } largeAlloc->Finalize(); finalizedValue = !finalizedValue; for(int i=0; i < kNumSizeClasses; i++) { #ifdef MMGC_DRC containsPointersRCAllocs[i]->m_finalized = false; #endif containsPointersAllocs[i]->m_finalized = false; noPointersAllocs[i]->m_finalized = false; } }

void* MMgc::GC::FindBeginning (  const void *  gcItem  )  [inline]

Requires(request) Definition at line 955 of file GC.h. References MMgc::GCLargeAlloc::FindBeginning(), MMgc::GCAlloc::FindBeginning(), GCAssert, GetUserPointer, MMgc::GCHeap::kBlockSize, and NULL. Referenced by avmplus::SortedIntMap< FrameState * >::ensureCapacity(), MMgc::WriteBarrierRC< T >::set(), avmplus::Hashtable::setAtoms(), avmplus::AtomArray::setAtoms(), WriteBarrier(), WriteBarrierNoSub(), and WriteBarrierWriteRC(). { GCAssert(gcItem != NULL); GCAssert(GetPageMapValue((uintptr)gcItem) != 0); void *realItem = NULL; if((uintptr)gcItem < memStart || (uintptr)gcItem >= memEnd) return NULL; int bits = GetPageMapValue((uintptr)gcItem); switch(bits) { case kGCAllocPage: realItem = GCAlloc::FindBeginning(gcItem); break; case kGCLargeAllocPageFirst: realItem = GCLargeAlloc::FindBeginning(gcItem); break; case kGCLargeAllocPageRest: while(bits == kGCLargeAllocPageRest) { gcItem = (void*) ((uintptr)gcItem - GCHeap::kBlockSize); bits = GetPageMapValue((uintptr)gcItem); } realItem = GCLargeAlloc::FindBeginning(gcItem); break; default: return NULL; } #ifdef MEMORY_INFO realItem = GetUserPointer(realItem); #endif return realItem; }

void MMgc::GC::FinishIncrementalMark (   )  [private]

Definition at line 2895 of file GC.cpp. References collecting, MMgc::GCStack< T, defSize >::Count(), GCAssert, GetPerformanceCounter(), MMgc::GCRoot::GetWorkItem(), hitZeroObjects, m_incrementalWork, m_roots, marking, MarkItem(), MarkQueueAndStack(), MMGC_ASSERT_EXCLUSIVE_GC, MMgc::GCRoot::next, MMgc::GCWorkItem::ptr, Sweep(), and sweepStart. Referenced by AllocBlockIncremental(), CollectImpl(), and IncrementalMark(). { MMGC_ASSERT_EXCLUSIVE_GC(this); // Don't finish an incremental mark (i.e., sweep) if we // are in the midst of a ZCT reap. if (zct.reaping) { return; } hitZeroObjects = false; // finished in Sweep sweepStart = GetPerformanceCounter(); // mark roots again, could have changed (alternative is to put WB's on the roots // which we may need to do if we find FinishIncrementalMark taking too long) { #ifdef GCHEAP_LOCK GCAcquireSpinlock lock(m_rootListLock); #endif GCRoot *r = m_roots; while(r) { GCWorkItem item = r->GetWorkItem(); // need to do this while holding the root lock so we don't end // up trying to scan a deleted item later, another reason to keep // the root set small if(item.ptr) { MarkItem(item, m_incrementalWork); } r = r->next; } } MarkQueueAndStack(m_incrementalWork); #ifdef _DEBUG // need to traverse all marked objects and make sure they don't contain // pointers to unmarked objects FindMissingWriteBarriers(); #endif GCAssert(!collecting); collecting = true; GCAssert(m_incrementalWork.Count() == 0); Sweep(); GCAssert(m_incrementalWork.Count() == 0); collecting = false; marking = false; }

void MMgc::GC::ForceSweep (   )  [inline, private]

Requires(exclusiveGC) Definition at line 1353 of file GC.h. Referenced by ~GC(). { Sweep(true); }

void MMgc::GC::Free (  const void *  ptr  )

One can free a GC allocated pointer, this will throw an assertion if called during the Sweep phase (ie via a finalizer) it can only be used outside the scope of a collection Requires(request) Definition at line 800 of file GC.cpp. References CheckThread(), ClearFinalized(), ClearWeakRef(), collecting, MMgc::GCAlloc::Free(), MMgc::GCLargeAlloc::Free(), GCAssert, GetRealPointer, HasWeakRef(), IsFinalized(), MMgc::GCLargeAlloc::IsLargeBlock(), IsQueued(), MMgc::GCAlloc::IsRCObject(), MMgc::GCLargeAlloc::IsRCObject(), largeAlloc, marking, NULL, SAMPLE_DEALLOC, and Size(). Referenced by avmplus::AtomArray::checkCapacity(), avmplus::AtomArray::clear(), avmplus::Hashtable::destroy(), avmplus::SortedIntMap< FrameState * >::ensureCapacity(), avmplus::MultinameHashtable::grow(), avmplus::BitSet::grow(), avmplus::Hashtable::grow(), MMgc::GCObject::operator delete(), MMgc::GCFinalizedObjectOptIn::operator delete(), MMgc::GCFinalizedObject::operator delete(), avmplus::StringOutputStream::write(), avmplus::AbcParser::~AbcParser(), avmplus::ArraySort::~ArraySort(), avmplus::BitSet::~BitSet(), avmplus::MultinameHashtable::~MultinameHashtable(), avmplus::ObjectVectorObject::~ObjectVectorObject(), avmplus::SortedIntMap< FrameState * >::~SortedIntMap(), avmplus::StringNullTerminatedUTF8::~StringNullTerminatedUTF8(), avmplus::StringOutputStream::~StringOutputStream(), avmplus::UsesUTF8String::~UsesUTF8String(), and avmplus::Verifier::~Verifier(). { #ifdef MMGC_THREADSAFE GCAutoLock _lock(m_lock); GCAssert(!m_gcRunning); #else CheckThread(); #endif if(item == NULL) { return; } bool isLarge; SAMPLE_DEALLOC(GetRealPointer(item), GC::Size(item)); // we can't allow free'ing something during Sweeping, otherwise alloc counters // get decremented twice and destructors will be called twice. if(collecting) { goto bail; } isLarge = GCLargeAlloc::IsLargeBlock(GetRealPointer(item)); if (marking) { // if its on the work queue don't delete it, if this item is // really garbage we're just leaving it for the next sweep if(IsQueued(item)) goto bail; } #ifdef _DEBUG #ifdef MMGC_DRC // RCObject have constract that they must clean themselves, since they // have to scan themselves to decrement other RCObjects they might as well // clean themselves too, better than suffering a memset later if(isLarge ? GCLargeAlloc::IsRCObject(item) : GCAlloc::IsRCObject(item)) { RCObjectZeroCheck((RCObject*)item); } #endif // MMGC_DRC #endif #ifdef MEMORY_INFO DebugFree(item, 0xca, 4); #endif if (isLarge) { largeAlloc->Free(GetRealPointer(item)); } else { GCAlloc::Free(GetRealPointer(item)); } return; bail: // this presumes we got here via delete, maybe we should have // delete call something other than the public Free to distinguish if(IsFinalized(item)) ClearFinalized(item); if(HasWeakRef(item)) ClearWeakRef(item); }

void MMgc::GC::FreeBits (  uint32 *  bits, int  sizeClass )  [inline, private]

Requires((request && m_lock) || exclusiveGC) Definition at line 1150 of file GC.h. References GCAssert, and util::threadpool::i. Referenced by MMgc::GCAlloc::FreeChunk(), and GetBits(). { #ifdef _DEBUG for(int i=0, n=noPointersAllocs[sizeClass]->m_numBitmapBytes; i<n;i++) GCAssert(((uint8*)bits)[i] == 0); #endif *(uint32**)bits = m_bitsFreelists[sizeClass]; m_bitsFreelists[sizeClass] = bits; }

void MMgc::GC::FreeBlock (  void *  ptr, uint32  size )

Requires((request && m_lock) || exclusiveGC) Definition at line 1151 of file GC.cpp. References allocsSinceCollect, collecting, destroying, MMgc::GCHeap::Free(), GCAssert, heap, totalGCPages, and UnmarkGCPages(). Referenced by MMgc::GCLargeAlloc::Free(), MMgc::GCAlloc::FreeChunk(), and Sweep(). { #ifdef MMGC_THREADSAFE GCAssert(m_lock.IsHeld() || destroying || (m_gcRunning && m_exclusiveGCThread == GCThread::GetCurrentThread())); #endif #ifdef DEBUGGER AllocActivity(- (int)size); #endif if(!collecting) { allocsSinceCollect -= size; } totalGCPages -= size; heap->Free(ptr); UnmarkGCPages(ptr, size); }

void MMgc::GC::gclog (  const char *  format,   ... )  [private]

Referenced by log_mem(), Sweep(), and updateGrossMemoryStats().

uint32 * MMgc::GC::GetBits (  int  numBytes, int  sizeClass )  [private]

Requires(request && m_lock) Definition at line 3072 of file GC.cpp. References MMgc::GCHeap::Alloc(), FreeBits(), GCAssert, heap, MMgc::GCHeap::kBlockSize, m_bitsFreelists, m_bitsNext, MMGC_ASSERT_GC_LOCK, and noPointersAllocs. Referenced by MMgc::GCAlloc::CreateChunk(). { uint32 *bits; MMGC_ASSERT_GC_LOCK(this); GCAssert(numBytes % 4 == 0); #ifdef MMGC_64BIT // we use first 8-byte slot for the free list if (numBytes == 4) numBytes = 8; #endif // hit freelists first if(m_bitsFreelists[sizeClass]) { bits = m_bitsFreelists[sizeClass]; m_bitsFreelists[sizeClass] = *(uint32**)bits; memset(bits, 0, sizeof(uint32*)); return bits; } if(!m_bitsNext) m_bitsNext = (uint32*)heap->Alloc(1); int leftOver = GCHeap::kBlockSize - ((uintptr)m_bitsNext & 0xfff); if(leftOver >= numBytes) { bits = m_bitsNext; if(leftOver == numBytes) m_bitsNext = 0; else m_bitsNext += numBytes/sizeof(uint32); } else { if(leftOver>=int(sizeof(void*))) { // put waste in freelist for(int i=0, n=kNumSizeClasses; i<n; i++) { GCAlloc *a = noPointersAllocs[i]; if(!a->m_bitsInPage && a->m_numBitmapBytes <= leftOver) { FreeBits(m_bitsNext, a->m_sizeClassIndex); break; } } } m_bitsNext = 0; // recurse rather than duplicating code return GetBits(numBytes, sizeClass); } return bits; }

size_t MMgc::GC::GetBytesInUse (   )

Definition at line 3388 of file GC.cpp. References containsPointersAllocs, MMgc::GCAlloc::GetBytesInUse(), MMGC_DRC, and noPointersAllocs. Referenced by updateGrossMemoryStats(). { size_t bytes=0; for(int i=0; i < kNumSizeClasses; i++) { #ifdef MMGC_DRC bytes += containsPointersRCAllocs[i]->GetBytesInUse(); #endif bytes += containsPointersAllocs[i]->GetBytesInUse(); bytes += noPointersAllocs[i]->GetBytesInUse(); } bytes += largeAlloc->GetBytesInUse(); return bytes; }

static GC* MMgc::GC::GetGC (  const void *  item  )  [inline, static]

Utility function: Returns the GC object associated with an allocated object Definition at line 836 of file GC.h. Referenced by avmplus::ObjectVectorObject::_setUintProperty(), avmplus::String::allocBuf(), avmplus::AtomArray::AtomArray(), avmplus::String::charAt(), avmplus::AtomArray::checkCapacity(), avmplus::AtomArray::clear(), avmplus::Hashtable::destroy(), avmplus::HeapMultiname::gc(), avmplus::E4XNode::gc(), avmplus::AvmCore::gcObjectToAtom(), MMgc::GCWorkItem::GCWorkItem(), avmplus::WeakValueHashtable::getValue(), GetWeakRef(), avmplus::ObjectVectorObject::grow(), avmplus::MultinameHashtable::grow(), avmplus::Hashtable::grow(), avmplus::MultinameHashtable::Init(), avmplus::String::localeCompare(), MMgc::GCObject::operator delete(), MMgc::GCFinalizedObjectOptIn::operator delete(), MMgc::GCFinalizedObject::operator delete(), avmplus::MultinameHashtable::put(), avmplus::Hashtable::put(), avmplus::Hashtable::reset(), MMgc::WriteBarrierRC< T >::set(), avmplus::AtomArray::setAtInternal(), avmplus::Hashtable::setAtoms(), avmplus::String::setBuf(), avmplus::ScriptObject::setDelegate(), avmplus::XMLObject::setNode(), avmplus::E4XNode::setParent(), avmplus::Namespace::setPrefix(), avmplus::String::setPrefixOrOffsetOrNumber(), avmplus::ScopeChain::setScope(), avmplus::XMLListObject::setTargetObject(), avmplus::Namespace::setUri(), avmplus::String::slice(), avmplus::String::sliceDouble(), avmplus::String::String(), avmplus::String::substr(), avmplus::String::substrDouble(), avmplus::String::substring(), avmplus::String::substringDouble(), avmplus::String::toLowerCase(), avmplus::String::toUpperCase(), avmplus::String::toUTF8String(), avmplus::XMLObject::toXMLString(), avmplus::StringOutputStream::write(), WriteBarrier(), WriteBarrierNoSub(), avmplus::BitSet::~BitSet(), MMgc::GCWeakRef::~GCWeakRef(), avmplus::MultinameHashtable::~MultinameHashtable(), avmplus::Namespace::~Namespace(), avmplus::ObjectVectorObject::~ObjectVectorObject(), avmplus::StringOutputStream::~StringOutputStream(), and avmplus::UsesUTF8String::~UsesUTF8String(). { GC **gc = (GC**) ((uintptr)item&~0xfff); return *gc; }

void* MMgc::GC::GetGCContextVariable (  int  var  )  const [inline]

Definition at line 565 of file GC.h. Referenced by AllocAlreadyLocked(), avmplus::String::charAt(), and avmplus::String::localeCompare(). { return m_contextVars[var]; }

GCHeap* MMgc::GC::GetGCHeap (   )  const [inline]

Definition at line 852 of file GC.h. Referenced by avmshell::SystemClass::getFreeMemory(), avmshell::SystemClass::getTotalMemory(), avmplus::PoolObject::PoolObject(), and MMgc::GCAlloc::~GCAlloc(). { return heap; }

int MMgc::GC::GetMark (  const void *  item  )  [static]

Tracers should employ GetMark and SetMark to set the mark bits during the mark pass. Requires(request || exclusiveGC) Definition at line 865 of file GC.cpp. References MMgc::GCAlloc::GetMark(), MMgc::GCLargeAlloc::GetMark(), GetRealPointer, and MMgc::GCLargeAlloc::IsLargeBlock(). Referenced by IsQueued(), and TrapWrite(). { item = GetRealPointer(item); if (GCLargeAlloc::IsLargeBlock(item)) { return GCLargeAlloc::GetMark(item); } else { return GCAlloc::GetMark(item); } }

int MMgc::GC::GetPageMapValue (  uintptr  addr  )  const [inline, private]

This spinlock covers memStart, memEnd, and the contents of pageMap. Definition at line 1260 of file GC.h. Referenced by IsGCMemory(), and IsWhite(). { #ifdef MMGC_THREADSAFE GCAcquireSpinlock lock(pageMapLock); #endif return GetPageMapValueAlreadyLocked(addr); }

int MMgc::GC::GetPageMapValueAlreadyLocked (  uintptr  addr  )  const [private]

Requires(pageMapLock) Definition at line 1169 of file GC.cpp. References GCAssert, MMgc::GCHeap::kBlockSize, memStart, and pageMap. Referenced by IsPointerToGCPage(). { uintptr index = (addr-memStart) >> 12; #ifdef MMGC_AMD64 GCAssert((index >> 2) < uintptr(64*65536) * uintptr(GCHeap::kBlockSize)); #else GCAssert(index >> 2 < 64 * GCHeap::kBlockSize); #endif // shift amount to determine position in the byte (times 2 b/c 2 bits per page) uint32 shiftAmount = (index&0x3) * 2; // 3 ... is mask for 2 bits, shifted to the left by shiftAmount // finally shift back by shift amount to get the value 0, 1 or 3 //return (pageMap[addr >> 2] & (3<<shiftAmount)) >> shiftAmount; return (pageMap[index >> 2] >> shiftAmount) & 3; }

uint64 MMgc::GC::GetPerformanceCounter (   )  [static]

Definition at line 2782 of file GC.cpp. References MMGC_PortAPI_Time, and NULL. Referenced by AllocBlock(), AllocBlockIncremental(), MMgc::GCHeap::Decommit(), duration(), FinishIncrementalMark(), MaybeGC(), StartIncrementalMark(), and Sweep(). { #if defined(MMGC_PORTING_API) return MMGC_PortAPI_Time(); #else #ifdef WIN32 LARGE_INTEGER value; QueryPerformanceCounter(&value); return value.QuadPart; #elif defined SOLARIS uint64 retval = gethrtime(); return retval; #elif defined(_MAC) return mach_absolute_time(); #elif defined(AVMPLUS_UNIX) struct timeval tv; ::gettimeofday(&tv, NULL); uint64 seconds = (uint64)(tv.tv_sec * 1000000); uint64 microseconds = (uint64)tv.tv_usec; uint64 result = seconds + microseconds; return result; #else #error "Need high res timer" #endif #endif // MMMGC_PORTING_API }

uint64 MMgc::GC::GetPerformanceFrequency (   )  [static]

Definition at line 2811 of file GC.cpp. References MMGC_PortAPI_Frequency. Referenced by duration(). { #if defined(MMGC_PORTING_API) return MMGC_PortAPI_Frequency(); #else #ifdef WIN32 static uint64 gPerformanceFrequency = 0; if (gPerformanceFrequency == 0) { QueryPerformanceFrequency((LARGE_INTEGER*)&gPerformanceFrequency); } return gPerformanceFrequency; #elif defined(_MAC) static mach_timebase_info_data_t info; static uint64 frequency = 0; if ( frequency == 0 ) { (void) mach_timebase_info(&info); frequency = (uint64) ( 1.0 / ( 1e-9 * (double) info.numer / (double) info.denom ) ); } return frequency; #elif defined(AVMPLUS_UNIX) return 1000000; #else #error "need high res time impl" #endif #endif // MMGC_PORTING_API }

uintptr MMgc::GC::GetStackTop (   )  const

GCWeakRef * MMgc::GC::GetWeakRef (  const void *  obj  )  [static]

Requires(request) Definition at line 3181 of file GC.cpp. References GCAssert, MMgc::GCWeakRef::get(), MMgc::GCHashtable::get(), GetGC(), GetRealPointer, MMgc::GCLargeAlloc::IsLargeBlock(), NULL, MMgc::GCHashtable::put(), MMgc::GCAlloc::SetHasWeakRef(), MMgc::GCLargeAlloc::SetHasWeakRef(), and weakRefs. Referenced by MMgc::GCFinalizedObject::GetWeakRef(), and MMgc::GCObject::GetWeakRef(). { GC *gc = GetGC(item); #ifdef MMGC_THREADSAFE GCAutoLock _lock(gc->m_lock); #endif GCWeakRef *ref = (GCWeakRef*) gc->weakRefs.get(item); if(ref == NULL) { ref = new (gc) GCWeakRef(item); gc->weakRefs.put(item, ref); item = GetRealPointer(item); if (GCLargeAlloc::IsLargeBlock(item)) { GCLargeAlloc::SetHasWeakRef(item, true); } else { GCAlloc::SetHasWeakRef(item, true); } } else { GCAssert(ref->get() == item); } return ref; }

static int MMgc::GC::HasWeakRef (  const void *  item  )  [inline, static]

Definition at line 818 of file GC.h. References GCAssert, GetRealPointer, MMgc::GCAlloc::HasWeakRef(), MMgc::GCLargeAlloc::HasWeakRef(), MMgc::GCLargeAlloc::IsLargeBlock(), and IsPointerToGCPage(). Referenced by Free(). { #ifdef MEMORY_INFO GC *gc = GetGC(item); item = GetRealPointer(item); GCAssert(gc->IsPointerToGCPage(item)); #endif if (GCLargeAlloc::IsLargeBlock(item)) { return GCLargeAlloc::HasWeakRef(item); } else { return GCAlloc::HasWeakRef(item); } }

void * MMgc::GC::heapAlloc (  size_t  size, bool  expand = true, bool  zero = true )  [private]

Definition at line 3362 of file GC.cpp. References MMgc::GCHeap::Alloc(), heap, and totalGCPages. { void *ptr = heap->Alloc((int)siz, expand, zero); if(ptr) totalGCPages += siz; return ptr; }

void MMgc::GC::heapFree (  void *  ptr, size_t  siz = 0 )  [private]

Definition at line 3370 of file GC.cpp. References MMgc::GCHeap::Free(), heap, MMgc::GCHeap::Size(), and totalGCPages. { if(!siz) siz = heap->Size(ptr); totalGCPages -= siz; heap->Free(ptr); }

void MMgc::GC::IncrementalMark (   )

Do as much marking as possible in time milliseconds Definition at line 2838 of file GC.cpp. References core(), MMgc::GCStack< T, defSize >::Count(), FinishIncrementalMark(), hitZeroObjects, incrementalValidation, m_incrementalWork, MMGC_ASSERT_EXCLUSIVE_GC, and SAMPLE_FRAME. Referenced by AllocBlockIncremental(), and MaybeGC(). { MMGC_ASSERT_EXCLUSIVE_GC(this); uint32 time = incrementalValidation ? 1 : 5; #ifdef _DEBUG time = 1; #endif SAMPLE_FRAME("[mark]", core()); if(m_incrementalWork.Count() == 0 || hitZeroObjects) { FinishIncrementalMark(); return; } #ifdef DEBUGGER StartGCActivity(); #endif markIncrements++; // FIXME: tune this so that getPerformanceCounter() overhead is noise static unsigned int checkTimeIncrements = 100; uint64 start = GetPerformanceCounter(); #ifdef DEBUGGER numObjects=0; objSize=0; #endif uint64 ticks = start + time * GetPerformanceFrequency() / 1000; do { unsigned int count = m_incrementalWork.Count(); if (count == 0) { hitZeroObjects = true; break; } if (count > checkTimeIncrements) { count = checkTimeIncrements; } for(unsigned int i=0; i<count; i++) { MarkItem(m_incrementalWork); } SAMPLE_CHECK(); } while(GetPerformanceCounter() < ticks); lastMarkTicks = GetPerformanceCounter(); markTicks += lastMarkTicks - start; if(gcstats) { double millis = duration(start); uint32 kb = objSize>>10; gclog("[mem] mark(%d) %d objects (%d kb %d mb/s) in %.2f millis (%.4f s)\n", markIncrements-lastStartMarkIncrementCount, numObjects, kb, uint32(double(kb)/millis), millis, duration(t0)/1000); } }

bool MMgc::GC::IncrementalMarking (   )  [inline]

Are we currently marking Definition at line 875 of file GC.h. { return marking; }

static int MMgc::GC::IsFinalized (  const void *  item  )  [inline, static]

Definition at line 804 of file GC.h. References GCAssert, GetRealPointer, MMgc::GCAlloc::IsFinalized(), MMgc::GCLargeAlloc::IsFinalized(), MMgc::GCLargeAlloc::IsLargeBlock(), and IsPointerToGCPage(). Referenced by Free(). { #ifdef MEMORY_INFO GC *gc = GetGC(item); item = GetRealPointer(item); GCAssert(gc->IsPointerToGCPage(item)); #endif if (GCLargeAlloc::IsLargeBlock(item)) { return GCLargeAlloc::IsFinalized(item); } else { return GCAlloc::IsFinalized(item); } }

bool MMgc::GC::IsGCMemory (  const void *   )

Requires(request || exclusiveGC) Definition at line 3061 of file GC.cpp. References GetPageMapValue(). { int bits = GetPageMapValue((uintptr)item); return (bits != 0); }

bool MMgc::GC::IsPointerToGCPage (  const void *  item  )

debugging tool Definition at line 1434 of file GC.cpp. References GetPageMapValueAlreadyLocked(), memEnd, memStart, and USING_PAGE_MAP. Referenced by ClearFinalized(), avmplus::BitSet::grow(), HasWeakRef(), IsFinalized(), IsWhite(), SetFinalize(), SetMark(), avmplus::StringOutputStream::StringOutputStream(), and writeBarrierRC(). { USING_PAGE_MAP(); if((uintptr)item >= memStart && (uintptr)item < memEnd) return GetPageMapValueAlreadyLocked((uintptr) item) != 0; return false; }

bool MMgc::GC::IsQueued (  const void *  item  )

Requires(request || exclusiveGC) Definition at line 3067 of file GC.cpp. References GetMark(), and IsWhite(). Referenced by Free(). { return !GetMark(item) && !IsWhite(item); }

bool MMgc::GC::IsRCObject (  const void *   )  [inline]

Definition at line 991 of file GC.h. Referenced by avmplus::AvmCore::gcObjectToAtom(), WriteBarrierWrite(), and WriteBarrierWriteRC(). { return false; }

int MMgc::GC::IsWhite (  const void *  item  )  [private]

Requires(request || exclusiveGC) Definition at line 2947 of file GC.cpp. References GetPageMapValue(), GetRealPointer, IsPointerToGCPage(), MMgc::GCLargeAlloc::IsWhite(), and MMgc::GCAlloc::IsWhite(). Referenced by IsQueued(), and TrapWrite(). { // back up to real beginning item = GetRealPointer((const void*) item); // normalize and divide by 4K to get index if(!IsPointerToGCPage(item)) return false; int bits = GetPageMapValue((uintptr)item); switch(bits) { case 1: return GCAlloc::IsWhite(item); case 3: // FIXME: we only want pointers to the first page for large items, fix // this by marking the first page and subsequent pages of large items differently // in the page map (ie use 2). return GCLargeAlloc::IsWhite(item); } return false; }

void MMgc::GC::log_mem (  const char *  name, size_t  s, size_t  comp )  [private]

Definition at line 3378 of file GC.cpp. References gclog(), and MMgc::GCHeap::kBlockSize. Referenced by updateGrossMemoryStats(). { bytes_compare = size_t((bytes*100.0)/bytes_compare); if(bytes > 1<<20) { gclog("%s %d (%.1fM) %d%%\n", name, bytes / GCHeap::kBlockSize, bytes * 1.0 / (1024*1024), bytes_compare); } else { gclog("%s %d (%dK) %d%%\n", name, bytes / GCHeap::kBlockSize, bytes / 1024, bytes_compare); } }

void MMgc::GC::Mark (  GCStack< GCWorkItem > &  work  )  [private]

Requires(exclusiveGC) Definition at line 1208 of file GC.cpp. References MMgc::GCStack< T, defSize >::Count(), MarkItem(), and MMGC_ASSERT_EXCLUSIVE_GC. Referenced by MarkQueueAndStack(), and Sweep(). { MMGC_ASSERT_EXCLUSIVE_GC(this); while(work.Count()) { MarkItem(work); } }

void MMgc::GC::MarkGCPages (  void *  item, uint32  numpages, int  val )  [private]

Definition at line 1216 of file GC.cpp. References MMgc::GCHeap::Alloc(), heap, MMgc::GCHeap::kBlockSize, MMgc::MAX_UINTPTR, memEnd, memStart, pageMap, MMgc::GCHeap::Size(), and USING_PAGE_MAP. Referenced by AllocBlock(). { USING_PAGE_MAP(); uintptr addr = (uintptr)item; size_t shiftAmount=0; unsigned char *dst = pageMap; // save the current live range in case we need to move/copy size_t numBytesToCopy = (memEnd-memStart)>>14; if(addr < memStart) { // round down to nearest 16k boundary, makes shift logic work cause it works // in bytes, ie 16k chunks addr &= ~0x3fff; // marking earlier pages if(memStart != MAX_UINTPTR) { shiftAmount = (memStart - addr) >> 14; } memStart = addr; } if(addr + (numPages+1)*GCHeap::kBlockSize > memEnd) { // marking later pages memEnd = addr + (numPages+1)*GCHeap::kBlockSize; // round up to 16k memEnd = (memEnd+0x3fff)&~0x3fff; } uint32 numPagesNeeded = (uint32)(((memEnd-memStart)>>14)/GCHeap::kBlockSize + 1); if(numPagesNeeded > heap->Size(pageMap)) { dst = (unsigned char*)heap->Alloc(numPagesNeeded); } if(shiftAmount || dst != pageMap) { memmove(dst + shiftAmount, pageMap, numBytesToCopy); memset(dst, 0, shiftAmount); if(dst != pageMap) { heap->Free(pageMap); pageMap = dst; } } addr = (uintptr)item; while(numPages--) { GCAssert(GetPageMapValueAlreadyLocked(addr) == 0); SetPageMapValue(addr, to); addr += GCHeap::kBlockSize; } }

void MMgc::GC::MarkItem (  GCWorkItem &  workitem, GCStack< GCWorkItem > &  work )  [private]

Requires(exclusiveGC) Definition at line 2562 of file GC.cpp. References bytesMarked, GCAssert, MMgc::GCWorkItem::GetSize(), marks, MMgc::GCWorkItem::ptr, SetMark(), and validateDefRef. { size_t size = wi.GetSize(); uintptr *p = (uintptr*) wi.ptr; #ifdef WERNER_MODE MarkList me(wi); if(p == shouldGo) { MarkList *wl = MarkList::current; while(wl) { const char *name = ""; // To enable RTTI, you must change all your projects to use RTTI first. #if 0 static bool tryit = true; if (tryit) { try { const std::type_info *ti = &typeid(*(MMgc::GCFinalizedObject*)wl->wi.ptr); if (ti->name() && (int(ti->name()) > 0x10000)) name = ti->name(); } catch(...) { name = "unknown"; } } #endif if(wl->prev) sprintf(statusBuffer, "0x%x+%d -> 0x%x size=%d (%s)\n", (unsigned int)wl->prev->wi.ptr, wl->off, (unsigned int)wl->wi.ptr, wl->wi.GetSize(), name); else sprintf(statusBuffer, "0x%x : %d (%s)\n", (unsigned int)wl->wi.ptr, wl->wi.GetSize(), name); wl = wl->prev; OutputDebugString(statusBuffer); } sprintf(statusBuffer, "\n"); OutputDebugString(statusBuffer); //shouldGo = NULL; } #endif bytesMarked += size; marks++; uintptr *end = p + (size / sizeof(void*)); uintptr thisPage = (uintptr)p & ~0xfff; // set the mark bits on this guy if(wi.IsGCItem()) { int b = SetMark(wi.ptr); (void)b; #ifdef _DEBUG // def ref validation does a Trace which can // cause things on the work queue to be already marked // in incremental GC if(!validateDefRef) { GCAssert(!b); } #endif } else { GCAssert(!IsPointerToGCPage(wi.ptr)); } uintptr _memStart = memStart; uintptr _memEnd = memEnd; #ifdef DEBUGGER numObjects++; objSize+=(uint32)size; #endif while(p < end) { #ifdef WERNER_MODE MarkList::offset = (int)p - (int)wi.ptr; #endif uintptr val = *p++; if(val < _memStart || val >= _memEnd) continue; // normalize and divide by 4K to get index int bits = GetPageMapValue(val); if (bits == kGCAllocPage) { const void *item; GCAlloc::GCBlock *block = (GCAlloc::GCBlock*) (val & ~0xFFF); #ifdef MMGC_INTERIOR_PTRS item = (void*) val; #else // back up to real beginning item = GetRealPointer((const void*) (val & ~7)); #endif // guard against bogus pointers to the block header if(item < block->items) continue; int itemNum = GCAlloc::GetIndex(block, item); #ifdef MMGC_INTERIOR_PTRS // adjust |item| to the beginning of the allocation item = block->items + itemNum * block->size; #else // if |item| doesn't point to the beginning of an allocation, // it's not considered a pointer. if (block->items + itemNum * block->size != item) { #ifdef MMGC_64BIT // Doubly-inherited classes have two vtables so are offset 8 more bytes than normal. // Handle that here (shows up with PlayerScriptBufferImpl object in the Flash player) if ((block->items + itemNum * block->size + sizeof(void *)) == item) item = block->items + itemNum * block->size; else #endif // MMGC_64BIT continue; } #endif // inline IsWhite/SetBit // FIXME: see if using 32 bit values is faster uint32 *pbits = &block->GetBits()[itemNum>>3]; int shift = (itemNum&0x7)<<2; int bits2 = *pbits; //if(GCAlloc::IsWhite(block, itemNum)) if((bits2 & ((GCAlloc::kMark|GCAlloc::kQueued)<<shift)) == 0) { if(block->alloc->ContainsPointers()) { const void *realItem = item; uint32 itemSize = block->size; #ifdef MEMORY_INFO realItem = GetUserPointer(realItem); itemSize -= (uint32)DebugSize(); #endif if(((uintptr)realItem & ~0xfff) != thisPage) { *pbits = bits2 | (GCAlloc::kQueued << shift); block->gc->PushWorkItem(work, GCWorkItem(realItem, itemSize, true)); } else { // clear queued bit *pbits = bits2 & ~(GCAlloc::kQueued << shift); // skip stack for same page items, this recursion is naturally limited by // how many item can appear on a page, worst case is 8 byte linked list or // 512 GCWorkItem newItem(realItem, itemSize, true); MarkItem(newItem, work); } } else { //GCAlloc::SetBit(block, itemNum, GCAlloc::kMark); *pbits = bits2 | (GCAlloc::kMark << shift); } #if defined(MEMORY_INFO) GC::WriteBackPointer(item, (end==(void*)0x130000) ? p-1 : wi.ptr, block->size); #endif } } else if (IsLargeAllocPage(bits)) { //largeAlloc->ConservativeMark(work, (void*) (val&~7), workitem.ptr); const void* item; #ifdef MMGC_INTERIOR_PTRS if (bits == kGCLargeAllocPageFirst) { // guard against bogus pointers to the block header if ((val & 0xffff) < sizeof(GCLargeAlloc::LargeBlock)) continue; item = (void *) ((val & ~0xfff) | sizeof(GCLargeAlloc::LargeBlock)); } else { item = GetRealPointer(FindBeginning((void *) val)); } #else // back up to real beginning item = GetRealPointer((const void*) (val & ~7)); // If |item| doesn't point to the start of the page, it's not // really a pointer. if(((uintptr) item & 0xfff) != sizeof(GCLargeAlloc::LargeBlock)) continue; #endif GCLargeAlloc::LargeBlock *b = GCLargeAlloc::GetBlockHeader(item); if((b->flags & (GCLargeAlloc::kQueuedFlag|GCLargeAlloc::kMarkFlag)) == 0) { uint32 usize = b->usableSize; if((b->flags & GCLargeAlloc::kContainsPointers) != 0) { b->flags |= GCLargeAlloc::kQueuedFlag; const void *realItem = item; #ifdef MEMORY_INFO realItem = GetUserPointer(item); usize -= (uint32)DebugSize(); #endif b->gc->PushWorkItem(work, GCWorkItem(realItem, usize, true)); } else { // doesn't need marking go right to black b->flags |= GCLargeAlloc::kMarkFlag; } #if defined(MEMORY_INFO) GC::WriteBackPointer(item, end==(void*)0x130000 ? p-1 : wi.ptr, usize); #endif } } } }

void MMgc::GC::MarkItem (  GCStack< GCWorkItem > &  work  )  [inline, private]

Requires(exclusiveGC) Definition at line 1359 of file GC.h. References MMgc::GCStack< T, defSize >::Pop(). Referenced by FinishIncrementalMark(), Mark(), and PushWorkItem(). { GCWorkItem workitem = work.Pop(); MarkItem(workitem, work); }

void MMgc::GC::MarkQueueAndStack (  GCStack< GCWorkItem > &  work  )  [private]

Requires(exclusiveGC) Definition at line 1340 of file GC.cpp. References MMgc::GCWorkItem::_size, Mark(), MMgc::GCWorkItem::ptr, PushWorkItem(), and rememberedStackTop. Referenced by FinishIncrementalMark(). { GCWorkItem item; MMGC_GET_STACK_EXTENTS(this, item.ptr, item._size); // this is where we will clear to when CleanStack is called if(rememberedStackTop == 0 || rememberedStackTop > item.ptr) { rememberedStackTop = item.ptr; } PushWorkItem(work, item); Mark(work); }

void MMgc::GC::MaybeGC (  bool  callerHasActiveRequest = false  )

Perform some GC-related work if needed. Call this during application down time. In incremental mode, this may result in a call to StartIncrementalMark() or IncrementalMark(), which may in turn push the current GC cycle to completion. In non-incremental mode, this heuristically decides whether to do a full Collect(). Parameters: callerHasActiveRequest  Must be true iff the calling thread is already in a request. Definition at line 753 of file GC.cpp. References allocsSinceCollect, collectThreshold, CollectWithBookkeeping(), MMgc::GCHeap::GetFreeHeapSize(), GetPerformanceCounter(), MMgc::GCHeap::GetTotalHeapSize(), greedy, heap, heapSizeAtLastAlloc, incremental, IncrementalMark(), MMgc::kFreeSpaceDivisor, MMgc::kMarkSweepBurstTicks, lastSweepTicks, marking, runtests::now, StartIncrementalMark(), and totalGCPages. { if (greedy) { CollectWithBookkeeping(false, callerHasActiveRequest); } else if (marking) { IncrementalMark(); } else { #ifdef MMGC_THREADSAFE GCAutoLock _lock(m_lock); #endif // Burst logic to prevent collections from happening back to back. uint64 now = GetPerformanceCounter(); if (now - lastSweepTicks <= kMarkSweepBurstTicks) return; // Definitely start GC if the heap expanded due to FixedMalloc // allocations. The same heuristic applies to incremental and // non-incremental. bool force = (heapSizeAtLastAlloc > collectThreshold && heapSizeAtLastAlloc < heap->GetTotalHeapSize()); if (incremental) { if (force || (totalGCPages > collectThreshold && allocsSinceCollect * kFreeSpaceDivisor >= totalGCPages)) { StartIncrementalMark(); } } else { // Collect only if the heap is completely full (a conservative // heuristic). if (force || heap->GetFreeHeapSize() == 0) CollectWithBookkeeping(true, callerHasActiveRequest); } } }

static const void* MMgc::GC::Pointer (  const void *  p  )  [inline, static, private]

Definition at line 1457 of file GC.h. Referenced by WriteBarrier(), and WriteBarrierWriteRC(). { return (const void*)(((uintptr)p)&~7); }

void MMgc::GC::PushWorkItem (  GCStack< GCWorkItem > &  stack, GCWorkItem  item )  [private]

Definition at line 3170 of file GC.cpp. References MarkItem(), MMgc::GCWorkItem::ptr, and MMgc::GCStack< T, defSize >::Push(). { #ifdef RECURSIVE_MARK MarkItem(item, stack); #else if(item.ptr) { stack.Push(item); } #endif }

void MMgc::GC::PushWorkItem (  GCWorkItem &  item  )  [inline]

Definition at line 1131 of file GC.h. Referenced by MarkQueueAndStack(), and TrapWrite(). { PushWorkItem(m_incrementalWork, item); }

void MMgc::GC::RemoveCallback (  GCCallback *  cb  )  [private]

Definition at line 3157 of file GC.cpp. References m_callbacks, MMgc::GCCallback::nextCB, MMgc::GCCallback::prevCB, and USING_CALLBACK_LIST. Referenced by MMgc::GCCallback::Destroy(), and MMgc::GCCallback::~GCCallback(). { USING_CALLBACK_LIST(this); if( m_callbacks == cb ) m_callbacks = cb->nextCB; else cb->prevCB->nextCB = cb->nextCB; if(cb->nextCB) cb->nextCB->prevCB = cb->prevCB; }

void MMgc::GC::RemoveRoot (  GCRoot *  root  )  [private]

Definition at line 3132 of file GC.cpp. References m_roots, MMgc::GCRoot::next, and MMgc::GCRoot::prev. Referenced by MMgc::GCRoot::Destroy(), and MMgc::GCRoot::~GCRoot(). { #ifdef GCHEAP_LOCK GCAcquireSpinlock lock(m_rootListLock); #endif if( m_roots == root ) m_roots = root->next; else root->prev->next = root->next; if(root->next) root->next->prev = root->prev; }

static void MMgc::GC::SetFinalize (  const void *  item  )  [inline, static]

Definition at line 790 of file GC.h. References GCAssert, GetRealPointer, MMgc::GCLargeAlloc::IsLargeBlock(), IsPointerToGCPage(), MMgc::GCAlloc::SetFinalize(), and MMgc::GCLargeAlloc::SetFinalize(). Referenced by avmplus::RegExpObject::RegExpObject(). { #ifdef MEMORY_INFO GC *gc = GetGC(item); item = GetRealPointer(item); GCAssert(gc->IsPointerToGCPage(item)); #endif if (GCLargeAlloc::IsLargeBlock(item)) { GCLargeAlloc::SetFinalize(item); } else { GCAlloc::SetFinalize(item); } }

void MMgc::GC::SetGCContextVariable (  int  var, void *  val )  [inline]

Definition at line 566 of file GC.h. Referenced by avmplus::AvmCore::~AvmCore(). { m_contextVars[var] = val; }

static int MMgc::GC::SetMark (  const void *  item  )  [inline, static]

Definition at line 748 of file GC.h. References GCAssert, GetRealPointer, MMgc::GCLargeAlloc::IsLargeBlock(), IsPointerToGCPage(), NULL, MMgc::GCAlloc::SetMark(), and MMgc::GCLargeAlloc::SetMark(). Referenced by MarkItem(), and TrapWrite(). { GCAssert(item != NULL); #ifdef MEMORY_INFO GC *gc = GetGC(item); item = GetRealPointer(item); GCAssert(gc->IsPointerToGCPage(item)); #endif if (GCLargeAlloc::IsLargeBlock(item)) { return GCLargeAlloc::SetMark(item); } else { return GCAlloc::SetMark(item); } }

void MMgc::GC::SetPageMapValue (  uintptr  addr, int  val )  [private]

Set the pageMap bits for the given address. Those bits must be zero beforehand. Requires(pageMapLock) Definition at line 1186 of file GC.cpp. References GCAssert, MMgc::GCHeap::kBlockSize, memStart, and pageMap. { uintptr index = (addr-memStart) >> 12; #ifdef MMGC_AMD64 GCAssert((index >> 2) < uintptr(64*65536) * uintptr(GCHeap::kBlockSize)); #else GCAssert(index >> 2 < 64 * GCHeap::kBlockSize); #endif pageMap[index >> 2] |= (val<<((index&0x3)*2)); }

void MMgc::GC::SetQueued (  const void *  item  )  [inline]

Definition at line 763 of file GC.h. References GCAssert, GetRealPointer, MMgc::GCLargeAlloc::IsLargeBlock(), MMgc::GCAlloc::SetQueued(), and MMgc::GCLargeAlloc::SetQueued(). Referenced by TrapWrite(). { #ifdef MEMORY_INFO item = GetRealPointer(item); GCAssert(IsPointerToGCPage(item)); #endif if (GCLargeAlloc::IsLargeBlock(item)) { GCLargeAlloc::SetQueued(item); } else { GCAlloc::SetQueued(item); } }

static size_t MMgc::GC::Size (  const void *  ptr  )  [inline, static]

return the size of a piece of memory, may be bigger than what was asked for Requires(request || exclusiveGC) Definition at line 731 of file GC.h. References DebugSize, GCAssert, and MMgc::GCLargeAlloc::GetBlockHeader(). Referenced by AllocAlreadyLocked(), avmplus::AtomArray::capacity(), MMgc::GCLargeAlloc::Finalize(), Free(), avmplus::DictionaryObject::getKeyFromObject(), avmplus::ScriptObject::ScriptObject(), TrapWrite(), avmplus::StringOutputStream::write(), writeBarrierRC(), and avmplus::ArraySort::~ArraySort(). { GCAssert(GetGC(ptr)->IsGCMemory(ptr)); size_t size = GCLargeAlloc::GetBlockHeader(ptr)->usableSize; size -= DebugSize(); return size; }

void MMgc::GC::StartIncrementalMark (   )  [private]

Definition at line 2374 of file GC.cpp. References collecting, containsPointersAllocs, MMgc::GCStack< T, defSize >::Count(), GCAssert, GetPerformanceCounter(), kNumSizeClasses, lastStartMarkIncrementCount, m_incrementalWork, markIncrements, marking, MMGC_DRC, noPointersAllocs, stackCleaned, and MMgc::GCAlloc::SweepNeedsSweeping(). Referenced by AllocAlreadyLocked(), AllocBlock(), AllocBlockIncremental(), CollectImpl(), and MaybeGC(). { GCAssert(!marking); GCAssert(!collecting); lastStartMarkIncrementCount = markIncrements; // set the stack cleaning trigger stackCleaned = false; marking = true; GCAssert(m_incrementalWork.Count() == 0); uint64 start = GetPerformanceCounter(); // clean up any pages that need sweeping for(int i=0; i < kNumSizeClasses; i++) { #ifdef MMGC_DRC containsPointersRCAllocs[i]->SweepNeedsSweeping(); #endif containsPointersAllocs[i]->SweepNeedsSweeping(); noPointersAllocs[i]->SweepNeedsSweeping(); } // at this point every object should have no marks or be marked kFreelist #ifdef _DEBUG for(int i=0; i < kNumSizeClasses; i++) { #ifdef MMGC_DRC containsPointersRCAllocs[i]->CheckMarks(); #endif containsPointersAllocs[i]->CheckMarks(); noPointersAllocs[i]->CheckMarks(); } #endif { #ifdef GCHEAP_LOCK GCAcquireSpinlock lock(m_rootListLock); #endif GCRoot *r = m_roots; while(r) { GCWorkItem item = r->GetWorkItem(); if(item.ptr) MarkItem(item, m_incrementalWork); r = r->next; } } markTicks += GetPerformanceCounter() - start; IncrementalMark(); }

void MMgc::GC::Sweep (  bool  force = false  )  [private]

Requires(exclusiveGC) Definition at line 913 of file GC.cpp. References MMgc::GCAlloc::GCBlock::alloc, allocsSinceCollect, collecting, core(), duration(), Finalize(), FreeBlock(), MMgc::GCAlloc::FreeChunk(), MMgc::GCDebugMsg(), gclog(), gcstats, MMgc::GCLargeAlloc::LargeBlock::GetNumBlocks(), GetPerformanceCounter(), MMgc::GCHeap::GetUsedHeapSize(), heap, MMgc::GCHeap::kBlockSize, largeEmptyPageList, lastSweepTicks, m_callbacks, m_incrementalWork, Mark(), marking, MMGC_ASSERT_EXCLUSIVE_GC, MMgc::GCLargeAlloc::LargeBlock::next, MMgc::GCAlloc::GCBlock::next, next, MMgc::GCCallback::nextCB, NULL, MMgc::GCCallback::postsweep(), MMgc::GCCallback::presweep(), SAMPLE_CHECK, SAMPLE_FRAME, smallEmptyPageList, MMgc::GCAlloc::SweepGuts(), sweeps, sweepStart, t0, and USING_CALLBACK_LIST. Referenced by FinishIncrementalMark(). { MMGC_ASSERT_EXCLUSIVE_GC(this); // collecting must be true because it indicates allocations should // start out marked, we can't rely on write barriers below since // presweep could write a new GC object to a root collecting = true; SAMPLE_FRAME("[sweep]", core()); sweeps++; size_t heapSize = heap->GetUsedHeapSize(); #ifdef MEMORY_INFO if(heap->enableMemoryProfiling) { GCDebugMsg(false, "Pre sweep memory info:\n"); DumpMemoryInfo(); } #endif // invoke presweep on all callbacks { USING_CALLBACK_LIST(this); GCCallback *cb = m_callbacks; while(cb) { cb->presweep(); cb = cb->nextCB; } } SAMPLE_CHECK(); // if force is true we're being called from ~GC and this isn't necessary if(!force) { // we just executed mutator code which could have fired some WB's Mark(m_incrementalWork); } Finalize(); // if force is true we're being called from ~GC and this isn't necessary if(!force) { // we just executed mutator code which could have fired some WB's Mark(m_incrementalWork); } SAMPLE_CHECK(); // ISSUE: this could be done lazily at the expense other GC's potentially expanding // unnecessarily, not sure its worth it as this should be pretty fast GCAlloc::GCBlock *b = smallEmptyPageList; while(b) { GCAlloc::GCBlock *next = b->next; #ifdef _DEBUG b->alloc->SweepGuts(b); #endif b->alloc->FreeChunk(b); b = next; } smallEmptyPageList = NULL; SAMPLE_CHECK(); GCLargeAlloc::LargeBlock *lb = largeEmptyPageList; while(lb) { GCLargeAlloc::LargeBlock *next = lb->next; #ifdef MEMORY_INFO DebugFreeReverse(lb+1, 0xba, 3); #endif // FIXME: this makes for some chatty locking, maybe not a problem? FreeBlock(lb, lb->GetNumBlocks()); lb = next; } largeEmptyPageList = NULL; SAMPLE_CHECK(); #ifdef MEMORY_INFO if(heap->enableMemoryProfiling) { GCDebugMsg(false, "Post sweep memory info:\n"); DumpMemoryInfo(); } #endif // don't want postsweep to fire WB's marking = false; collecting = false; // invoke postsweep callback { USING_CALLBACK_LIST(this); GCCallback *cb = m_callbacks; while(cb) { cb->postsweep(); cb = cb->nextCB; } } SAMPLE_CHECK(); allocsSinceCollect = 0; lastSweepTicks = GetPerformanceCounter(); if(GC::gcstats) { int sweepResults = 0; GCAlloc::GCBlock *bb = smallEmptyPageList; while(bb) { sweepResults++; bb = bb->next; } GCLargeAlloc::LargeBlock *lbb = largeEmptyPageList; while(lbb) { sweepResults += lbb->GetNumBlocks(); lbb = lbb->next; } // include large pages given back sweepResults += int(heapSize - heap->GetUsedHeapSize()); double millis = duration(sweepStart); gclog("[mem] sweep(%d) reclaimed %d whole pages (%d kb) in %.2f millis (%.4f s)\n", sweeps, sweepResults, sweepResults*GCHeap::kBlockSize>>10, millis, duration(t0)/1000); } #ifdef DEBUGGER StopGCActivity(); #endif #ifdef MEMORY_INFO m_gcLastStackTrace = GetStackTraceIndex(5); #endif }

static uint64 MMgc::GC::ticksToMicros (  uint64  ticks  )  [inline, static]

Definition at line 1029 of file GC.h. { #ifdef WIN32 return (ticks*1000000)/GetPerformanceFrequency(); #else return ticks; #endif }

static uint64 MMgc::GC::ticksToMillis (  uint64  ticks  )  [inline, static]

Definition at line 1039 of file GC.h. { #ifdef WIN32 return (ticks*1000)/GetPerformanceFrequency(); #else return ticks/1000; #endif }

void MMgc::GC::TrapWrite (  const void *  black, const void *  white )  [private]

Write barrier slow path. Queues the white object. Requires(request) Definition at line 3029 of file GC.cpp. References ContainsPointers(), GCAssert, GetMark(), IsWhite(), m_incrementalWork, marking, PushWorkItem(), SetMark(), SetQueued(), and Size(). { // assert fast path preconditions (void)black; GCAssert(marking); GCAssert(GetMark(black)); GCAssert(IsWhite(white)); // currently using the simplest finest grained implementation, // which could result in huge work queues. should try the // more granular approach of moving the black object to grey // (smaller work queue, less frequent wb slow path) but if the // black object is big we end up doing useless redundant // marking. optimal approach from lit is card marking (mark a // region of the black object as needing to be re-marked) if(ContainsPointers(white)) { SetQueued(white); PushWorkItem(m_incrementalWork, GCWorkItem(white, (uint32)Size(white), true)); } else { SetMark(white); } }

void MMgc::GC::UnmarkGCPages (  void *  item, uint32  numpages )  [private]

Definition at line 1267 of file GC.cpp. References ClearPageMapValue(), MMgc::GCHeap::kBlockSize, and USING_PAGE_MAP. Referenced by FreeBlock(). { uintptr addr = (uintptr) item; USING_PAGE_MAP(); while(numpages--) { ClearPageMapValue(addr); addr += GCHeap::kBlockSize; } }

void MMgc::GC::updateGrossMemoryStats (   )  [private]

Definition at line 3402 of file GC.cpp. References gclog(), MMgc::GCHashtable::get(), MMgc::FixedMalloc::GetBytesInUse(), GetBytesInUse(), MMgc::GCHeap::GetFreeHeapSize(), MMgc::FixedMalloc::GetInstance(), MMgc::GCHeap::GetPrivateBytes(), MMgc::GCHeap::GetTotalHeapSize(), MMgc::FixedMalloc::GetTotalSize(), heap, MMgc::GCHeap::kBlockSize, log_mem(), stats, and totalGCPages. { size_t priv = GCHeap::GetPrivateBytes() * GCHeap::kBlockSize; size_t mmgc = heap->GetTotalHeapSize() * GCHeap::kBlockSize; size_t unmanaged = FixedMalloc::GetInstance()->GetTotalSize() * GCHeap::kBlockSize; size_t jit = (size_t)stats.get("jit") * GCHeap::kBlockSize; size_t gc_alloced = GetBytesInUse(); size_t fixed_alloced = FixedMalloc::GetInstance()->GetBytesInUse(); size_t gc = totalGCPages * GCHeap::kBlockSize; gclog("[mem] ------- gross stats -----\n"); log_mem("[mem] private", priv, priv); log_mem("[mem]\t mmgc", mmgc, priv); log_mem("[mem]\t\t unmanaged", unmanaged, priv); log_mem("[mem]\t\t managed", gc, priv); log_mem("[mem]\t\t free", (size_t)heap->GetFreeHeapSize() * GCHeap::kBlockSize, priv); log_mem("[mem]\t jit", jit, priv); log_mem("[mem]\t other", priv - jit - mmgc, priv); log_mem("[mem] bytes (interal fragmentation)", fixed_alloced + gc_alloced, gc + unmanaged); log_mem("[mem] \tmanaged bytes ", gc_alloced, gc); log_mem("[mem] \tunmanaged bytes ", fixed_alloced, unmanaged); gclog("[mem] -------- gross stats end -----\n"); }

void MMgc::GC::UpdateStat (  const char *  key, int  delta )  [inline]

Definition at line 1545 of file GC.h. { stats.put(key, (const void*)((size_t)stats.get(key) + delta)); }

void MMgc::GC::writeBarrier (  const void *  container, const void *  address, const void *  value )  [inline]

Requires(request) Definition at line 890 of file GC.h. References GCAssert. Referenced by avmplus::Hashtable::setAtoms(). { GCAssert(!container || IsPointerToGCPage(container)); GCAssert(((uintptr)address & 3) == 0); if (container) { GCAssert(address >= container); GCAssert(address < (char*)container + Size(container)); WriteBarrierNoSubstitute(container, value); } WriteBarrierWrite(address, value); }

void MMgc::GC::WriteBarrier (  const void *  address, const void *  value )  [static]

A magical write barrier that finds the container's address and the GC, just make sure address is a pointer to a GC page. Only used by WB smart pointers. Requires(request) Definition at line 3010 of file GC.cpp. References FindBeginning(), GetGC(), marking, NULL, Pointer(), WriteBarrierNoSubstitute(), and WriteBarrierWrite(). Referenced by MMgc::WriteBarrier< T >::set(). { GC* gc = GC::GetGC(address); if(Pointer(value) != NULL && gc->marking) { void *container = gc->FindBeginning(address); gc->WriteBarrierNoSubstitute(container, value); } gc->WriteBarrierWrite(address, value); }

void MMgc::GC::WriteBarrierNoSub (  const void *  address, const void *  value )  [static]

Requires(request) Definition at line 3020 of file GC.cpp. References FindBeginning(), GetGC(), marking, NULL, and WriteBarrierNoSubstitute(). { GC *gc = NULL; if(value != NULL && (gc = GC::GetGC(address))->marking) { void *container = gc->FindBeginning(address); gc->WriteBarrierNoSubstitute(container, value); } }

__forceinline void MMgc::GC::WriteBarrierNoSubstitute (  const void *  container, const void *  value )  [inline]

Write barrier when the value could be a pointer with anything in the lower 3 bits FIXME: maybe assert that the lower 3 bits are either zero or a pointer type signature, this would require the application to tell us what bit patterns are pointers. Requires(request) Definition at line 917 of file GC.h. Referenced by avmplus::AvmCore::atomWriteBarrier(), avmplus::String::setPrefixOrOffsetOrNumber(), WriteBarrier(), WriteBarrierNoSub(), and writeBarrierRC(). { WriteBarrierTrap(container, (const void*)((uintptr)value&~7)); }

void MMgc::GC::writeBarrierRC (  const void *  container, const void *  address, const void *  value )

optimized version with no RC checks or pointer masking Requires(request) Definition at line 2976 of file GC.cpp. References GCAssert, IsPointerToGCPage(), Size(), WriteBarrierNoSubstitute(), and WriteBarrierWriteRC(). Referenced by MMgc::WriteBarrierRC< T >::set(). { GCAssert(IsPointerToGCPage(container)); GCAssert(((uintptr)container & 3) == 0); GCAssert(((uintptr)address & 2) == 0); GCAssert(address >= container); GCAssert(address < (char*)container + Size(container)); WriteBarrierNoSubstitute(container, value); WriteBarrierWriteRC(address, value); }

__forceinline void MMgc::GC::WriteBarrierTrap (  const void *  container, const void *  valuePtr )  [inline]

AVM+ write barrier, valuePtr is known to be pointer and the caller does the write. Requires(request) Definition at line 928 of file GC.h. References GCAssert. { GCAssert(IsPointerToGCPage(container)); GCAssert(((uintptr)valuePtr&7) == 0); GCAssert(IsPointerToGCPage(container)); if(marking && valuePtr && GetMark(container) && IsWhite(valuePtr)) { TrapWrite(container, valuePtr); } }

void MMgc::GC::WriteBarrierWrite (  const void *  address, const void *  value )  [private]

Definition at line 2969 of file GC.cpp. References GCAssert, and IsRCObject(). Referenced by WriteBarrier(). { GCAssert(!IsRCObject(value)); *(uintptr*)address = (uintptr) value; }

void MMgc::GC::WriteBarrierWriteRC (  const void *  address, const void *  value )  [private]

Definition at line 2989 of file GC.cpp. References FindBeginning(), GCAssert, IsRCObject(), NULL, and Pointer(). Referenced by writeBarrierRC(). { #ifdef MMGC_DRC RCObject *rc = (RCObject*)Pointer(*(RCObject**)address); if(rc != NULL) { GCAssert(rc == FindBeginning(rc)); GCAssert(IsRCObject(rc)); rc->DecrementRef(); } #endif *(uintptr*)address = (uintptr) value; #ifdef MMGC_DRC rc = (RCObject*)Pointer(value); if(rc != NULL) { GCAssert(IsRCObject(rc)); GCAssert(rc == FindBeginning(value)); rc->IncrementRef(); } #endif }

---

Friends And Related Function Documentation

friend class GCAlloc [friend]

Definition at line 549 of file GC.h. Referenced by GC().

friend class GCCallback [friend]

Definition at line 548 of file GC.h.

friend class GCInterval [friend]

Definition at line 552 of file GC.h.

friend class GCLargeAlloc [friend]

Definition at line 550 of file GC.h.

friend class GCRoot [friend]

Definition at line 547 of file GC.h. Referenced by CollectWithBookkeeping().

friend class RCObject [friend]

Definition at line 551 of file GC.h.

friend class ZCT [friend]

Definition at line 553 of file GC.h.

---

Member Data Documentation

unsigned int MMgc::GC::allocsSinceCollect [private]

Number of pages allocated from the GCHeap since the start of the current GC cycle. Requires((request && m_lock) || exclusiveGC) Definition at line 1380 of file GC.h. Referenced by AllocBlock(), AllocBlockIncremental(), AllocBlockNonIncremental(), FreeBlock(), MaybeGC(), and Sweep().

uint64 MMgc::GC::bytesMarked

Total number of bytes of pointer-containing memory scanned by this GC. Used to measure marking rate, which is bytesMarked/ticksToMillis(markTicks). ReadWrite(request, exclusiveGC) Definition at line 1055 of file GC.h. Referenced by MarkItem().

bool MMgc::GC::collecting [private]

True during the sweep phase of collection. Several things have to behave a little differently during this phase. For example, GC::Free() does nothing during sweep phase; otherwise finalizers could be called twice. Also, Collect() uses this to protect itself from recursive calls (from badly behaved finalizers). ReadWrite(request, exclusiveGC) Definition at line 1393 of file GC.h. Referenced by MMgc::GCLargeAlloc::Alloc(), MMgc::GCAlloc::Alloc(), AllocBlock(), AllocBlockIncremental(), CollectWithBookkeeping(), MMgc::GCAlloc::CreateChunk(), FinishIncrementalMark(), Free(), FreeBlock(), StartIncrementalMark(), and Sweep().

size_t MMgc::GC::collectThreshold

Expand, don't collect, until we reach this threshold. Units are pages, not KB, just like GCHeap::GetTotalHeapSize(). In an MMGC_THREADSAFE build, the GC reads this configuration value only when holding the GC lock. Set it during initialization, before the GC is visible to multiple threads. Requires(m_lock) Definition at line 613 of file GC.h. Referenced by AllocBlock(), AllocBlockIncremental(), AllocBlockNonIncremental(), and MaybeGC().

GCAlloc* MMgc::GC::containsPointersAllocs[kNumSizeClasses] [private]

Definition at line 1295 of file GC.h. Referenced by AllocAlreadyLocked(), ClearMarks(), Finalize(), GC(), GetBytesInUse(), and StartIncrementalMark().

bool MMgc::GC::destroying [private]

Definition at line 1167 of file GC.h. Referenced by FreeBlock(), and ~GC().

bool MMgc::GC::disableThreadCheck [private]

Definition at line 1191 of file GC.h. Referenced by CheckThread().

bool MMgc::GC::dontAddToZCTDuringCollection

Definition at line 627 of file GC.h.

bool MMgc::GC::finalizedValue [private]

Requires((request && m_lock) || exclusiveGC) Definition at line 1396 of file GC.h. Referenced by MMgc::GCAlloc::CreateChunk().

bool MMgc::GC::findUnmarkedPointers

findUnmarkedPointers is a debugging flag, only Definition at line 594 of file GC.h.

bool MMgc::GC::gcstats

If true, log some statistics during each collection. The output goes to gclog(). In an MMGC_THREADSAFE build, the GC reads this flag only during stop-the-world collection. Set it during initialization, before the GC is visible to multiple threads. Requires(exclusiveGC) Definition at line 625 of file GC.h. Referenced by Sweep().

bool MMgc::GC::greedy

greedy is a debugging flag. When set, every allocation will cause a garbage collection. This makes code run abysmally slow, but can be useful for detecting mark bugs. The GC reads this flag only when holding the GC lock. It is best to set it as soon as the GC is created. Requires(m_lock) Definition at line 581 of file GC.h. Referenced by AllocAlreadyLocked(), and MaybeGC().

GCHeap* MMgc::GC::heap [private]

Definition at line 1301 of file GC.h. Referenced by AllocBlock(), AllocBlockIncremental(), AllocBlockNonIncremental(), FreeBlock(), GetBits(), heapAlloc(), heapFree(), MarkGCPages(), MaybeGC(), Sweep(), and updateGrossMemoryStats().

size_t MMgc::GC::heapSizeAtLastAlloc [private]

We track the heap size so if it expands due to fixed memory allocations we can trigger a mark/sweep. Otherwise we can have lots of small GC objects allocating tons of fixed memory, which results in huge heaps and possible out of memory situations. Requires(m_lock) Definition at line 1177 of file GC.h. Referenced by AllocBlock(), and MaybeGC().

bool MMgc::GC::hitZeroObjects

True if we emptied the work queue during the most recent incremental mark. This means the next mark will force the GC cycle through to completion. ReadWrite(request, exclusiveGC) Definition at line 1111 of file GC.h. Referenced by FinishIncrementalMark(), and IncrementalMark().

bool MMgc::GC::incremental

Configuration flag enabling incremental collection. In an MMGC_THREADSAFE build, the GC reads this flag only when holding the GC lock. Set it during initialization. Requires(m_lock) Definition at line 642 of file GC.h. Referenced by AllocBlock(), and MaybeGC().

bool MMgc::GC::incrementalValidation

Definition at line 628 of file GC.h. Referenced by AllocBlockIncremental(), and IncrementalMark().

bool MMgc::GC::keepDRCHistory

Definition at line 601 of file GC.h.

const int MMgc::GC::kNumSizeClasses = 40 [static, private]

Definition at line 1141 of file GC.h. Referenced by ClearMarks(), Finalize(), GC(), StartIncrementalMark(), and ~GC().

const int MMgc::GC::kPageUsableSpace = 3936 [static, private]

Definition at line 1144 of file GC.h.

const int16 MMgc::GC::kSizeClasses [static, private]

Initial value: { 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 144, 160, 168, 176, 184, 192, 200, 216, 224, 240, 256, 280, 296, 328, 352, 392, 432, 488, 560, 656, 784, 984, 1312, 1968 } Definition at line 1216 of file GC.h. Referenced by GC().

const uint8 MMgc::GC::kSizeClassIndex [static, private]

Initial value: { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16, 17, 17, 18, 19, 20, 21, 22, 23, 23, 24, 25, 25, 26, 26, 27, 27, 27, 28, 28, 29, 29, 29, 29, 30, 30, 30, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39 } Definition at line 1217 of file GC.h. Referenced by AllocAlreadyLocked().

GCLargeAlloc* MMgc::GC::largeAlloc [private]

Definition at line 1300 of file GC.h. Referenced by AllocAlreadyLocked(), and Free().

GCLargeAlloc::LargeBlock* MMgc::GC::largeEmptyPageList [private]

List of pages to be swept, built up in Finalize. Requires(exclusiveGC) Definition at line 1422 of file GC.h. Referenced by Sweep().

uint64 MMgc::GC::lastMarkTicks [private]

ReadWrite(request, exclusiveGC) Definition at line 1212 of file GC.h. Referenced by AllocBlockIncremental().

uint32 MMgc::GC::lastStartMarkIncrementCount

Definition at line 1066 of file GC.h. Referenced by StartIncrementalMark().

uint64 MMgc::GC::lastSweepTicks [private]

ReadWrite(request, exclusiveGC) Definition at line 1214 of file GC.h. Referenced by AllocBlock(), AllocBlockIncremental(), MaybeGC(), and Sweep().

uint32* MMgc::GC::m_bitsFreelists[kNumSizeClasses] [private]

Requires((request && m_lock) || exclusiveGC) Definition at line 1160 of file GC.h. Referenced by GetBits(), and ~GC().

uint32* MMgc::GC::m_bitsNext [private]

Requires((request && m_lock) || exclusiveGC) Definition at line 1162 of file GC.h. Referenced by GetBits().

GCCallback* MMgc::GC::m_callbacks [private]

Points to the head of a linked list of callback objects. Requires(m_callbackListLock) Definition at line 1442 of file GC.h. Referenced by AddCallback(), CollectWithBookkeeping(), RemoveCallback(), and Sweep().

void* MMgc::GC::m_contextVars[GCV_COUNT] [private]

Definition at line 1219 of file GC.h.

GCStack<GCWorkItem> MMgc::GC::m_incrementalWork [private]

Definition at line 1204 of file GC.h. Referenced by FinishIncrementalMark(), IncrementalMark(), StartIncrementalMark(), Sweep(), and TrapWrite().

GCRoot* MMgc::GC::m_roots [private]

Requires(m_rootListLock) Definition at line 1429 of file GC.h. Referenced by AddRoot(), FinishIncrementalMark(), and RemoveRoot().

uint32 MMgc::GC::markIncrements

Definition at line 1067 of file GC.h. Referenced by StartIncrementalMark().

bool MMgc::GC::marking [private]

True if incremental marking is on and some objects have been marked. This means write barriers are enabled. ReadWrite(request, exclusiveGC) The GC thread may read and write this flag. Application threads in requests have read-only access. Definition at line 1203 of file GC.h. Referenced by AllocAlreadyLocked(), AllocBlock(), AllocBlockIncremental(), CollectImpl(), FinishIncrementalMark(), Free(), MaybeGC(), StartIncrementalMark(), Sweep(), TrapWrite(), WriteBarrier(), and WriteBarrierNoSub().

uint32 MMgc::GC::marks

Number of calls to MarkItem(). ReadWrite(request, exclusiveGC) Definition at line 1073 of file GC.h. Referenced by MarkItem().

uint64 MMgc::GC::markTicks

Total time spent doing incremental marking, in ticks. See bytesMarked. ReadWrite(request, exclusiveGC) Definition at line 1063 of file GC.h.

uintptr MMgc::GC::memEnd [private]

Requires(pageMapLock) Definition at line 1229 of file GC.h. Referenced by IsPointerToGCPage(), and MarkGCPages().

uintptr MMgc::GC::memStart [private]

Requires(pageMapLock) Definition at line 1227 of file GC.h. Referenced by ClearPageMapValue(), GetPageMapValueAlreadyLocked(), IsPointerToGCPage(), MarkGCPages(), and SetPageMapValue().

bool MMgc::GC::nogc

nogc is a debugging flag. When set, garbage collection never happens. Requires(m_lock) Definition at line 589 of file GC.h. Referenced by AllocBlock(), AllocBlockIncremental(), and CollectWithBookkeeping().

GCAlloc* MMgc::GC::noPointersAllocs[kNumSizeClasses] [private]

Definition at line 1299 of file GC.h. Referenced by AllocAlreadyLocked(), ClearMarks(), Finalize(), GC(), GetBits(), GetBytesInUse(), and StartIncrementalMark().

uint32 MMgc::GC::numObjects

Number of calls to MarkItem() during the current (or most recent) IncrementalMark(). ReadWrite(request, exclusiveGC) Definition at line 1087 of file GC.h.

uint32 MMgc::GC::objSize

Number of bytes scanned in MarkItem() during the current (or most recent) IncrementalMark(). ReadWrite(request, exclusiveGC) Definition at line 1095 of file GC.h.

unsigned char* MMgc::GC::pageMap [private]

The bitmap for what pages are in use. Any access to either the pageMap pointer or the bitmap requires pageMapLock. (Note: A better synchronization scheme might be to use atomic operations to read and write the pageMap pointer, writing it only from within m_lock; and then using atomic read and write operations--on Intel x86, these are just ordinary reads and writes--to access the bitmap, with writes again only from within m_lock. This would require reallocating the pageMap more often, but at least write barriers wouldn't have to acquire the spinlock.) Requires(pageMapLock) Definition at line 1251 of file GC.h. Referenced by ClearPageMapValue(), GetPageMapValueAlreadyLocked(), MarkGCPages(), and SetPageMapValue().

const void* MMgc::GC::rememberedStackBottom [private]

Definition at line 1187 of file GC.h. Referenced by CleanStack(), and GC().

const void* MMgc::GC::rememberedStackTop [private]

Definition at line 1186 of file GC.h. Referenced by CleanStack(), and MarkQueueAndStack().

GCAlloc::GCBlock* MMgc::GC::smallEmptyPageList [private]

List of pages to be swept, built up in Finalize. Requires(exclusiveGC) Definition at line 1409 of file GC.h. Referenced by Sweep().

bool MMgc::GC::stackCleaned [private]

Definition at line 1185 of file GC.h. Referenced by CleanStack(), and StartIncrementalMark().

GCHashtable MMgc::GC::stats [private]

Definition at line 1234 of file GC.h. Referenced by updateGrossMemoryStats().

uint32 MMgc::GC::sweeps

Number of calls to Sweep(). ReadWrite(request, exclusiveGC) Definition at line 1079 of file GC.h. Referenced by Sweep().

uint64 MMgc::GC::sweepStart

Time of the latest FinishIncrementalMark() call, in ticks. ReadWrite(request, exclusiveGC) Definition at line 1102 of file GC.h. Referenced by FinishIncrementalMark(), and Sweep().

const uint64 MMgc::GC::t0

GC initialization time, in ticks. Used for logging. Definition at line 1026 of file GC.h. Referenced by Sweep().

size_t MMgc::GC::totalGCPages [private]

Requires(m_lock) Definition at line 1232 of file GC.h. Referenced by AllocBlock(), AllocBlockIncremental(), AllocBlockNonIncremental(), FreeBlock(), heapAlloc(), heapFree(), MaybeGC(), and updateGrossMemoryStats().

bool MMgc::GC::validateDefRef

turns on code that does a trace before reaping zero count object and asserting on any objects that get marked, debug builds only Definition at line 600 of file GC.h. Referenced by MarkItem().

GCHashtable MMgc::GC::weakRefs [private]

Requires((request && m_lock) || exclusiveGC) Definition at line 1165 of file GC.h. Referenced by ClearWeakRef(), and GetWeakRef().

---

The documentation for this class was generated from the following files:

• tamarin-central/MMgc/GC.h
• tamarin-central/MMgc/GC.cpp

---