private static unsafe void removeFromPLCList(PLCLink *pLinkAddr)
{
// The object needs to be removed from the PLC list.
PLCLink *currPLCLink = pLinkAddr;
#if DEBUG
VTable.Assert(currPLCLink->next != null,
@"currPLCLink->next != null");
#endif // DEBUG
PLCLink *linkToSkip = currPLCLink->next;
PLCLink *linkAfter = linkToSkip->next;
currPLCLink->next = linkAfter;
linkToSkip->next = plcListChunk;
plcListChunk = linkToSkip;
// Update the PLC link pointer in the following object.
if (linkAfter != null)
{
UIntPtr nextObjAddr = linkAfter->objAddr;
Object nextObj = Magic.fromAddress(nextObjAddr);
#if DEBUG
VTable.Assert(getPLCLink(nextObj) == linkToSkip,
@"getPLCLink(nextObj) == linkToSkip");
#endif // DEBUG
setPLCLink(nextObj, currPLCLink);
}
}
private static unsafe void addToPLCList(Object obj)
{
// Check if free PLC links are available.
if (plcListChunk == null)
{
if (numPLCChunks < maxPLCChunks)
{
// Allocate a chunk of PLC links.
int threadIndex = Thread.GetCurrentThreadIndex();
Thread t = Thread.threadTable[threadIndex];
UIntPtr resultAddr =
t.segregatedFreeList.
Allocate(plcListChunkBytes,
plcListVtable.baseAlignment);
Object result = Magic.fromAddress(resultAddr);
result.REF_STATE = 2 & ~countingONFlagMask;
result.vtable = plcListVtable;
numPLCChunks++;
// Point <plcListChunk> to the first element
// in the allocated array of PLC links and string
// the elements into a free PLC links' list.
plcListChunk = (PLCLink *)
(resultAddr + PostHeader.Size + UIntPtr.Size);
for (PLCLink *link = plcListChunk;
link < plcListChunk +
plcListChunkLength - 1;
link++)
{
link->next = link + 1;
}
}
else
{
processPLCList();
}
}
VTable.Assert(plcListChunk != null,
@"plcListChunk != null");
// Insert object into the PLC list by moving a link
// from the free PLC links' chunk.
firstPLCLink->objAddr = Magic.addressOf(obj);
PLCLink *currPLCLink = plcListChunk;
plcListChunk = plcListChunk->next;
currPLCLink->next = firstPLCLink;
firstPLCLink = currPLCLink;
firstPLCLink->objAddr = UIntPtr.Zero;
// Point the object to its link in the PLC list.
setPLCLink(obj, firstPLCLink);
}
internal override unsafe void Visit(UIntPtr *loc)
{
UIntPtr objAddr = *loc;
Object obj = Magic.fromAddress(objAddr);
uint refState = obj.REF_STATE;
if ((refState & countingONFlagMask) == 0)
{
return;
}
uint refCount = refState & refCountMask;
VTable.Assert(refCount < refCountMask,
@"refCount < refCountMask");
refState++;
if ((refState & markFlagMask) != 0)
{
// The object hasn't been visited either
// by the scanner or the incrementer.
obj.REF_STATE = refState & ~markFlagMask;
this.workList.Write(objAddr);
// This object isn't leaked data, so
// clear the PLC link in its header.
setPLCLink(obj, null);
}
else if ((refState & refCountMask) == 1)
{
// The object has been visited in the
// past, but only by the scanner.
obj.REF_STATE = refState;
this.workList.Write(objAddr);
// This object isn't leaked data, so
// clear the PLC link in its header.
setPLCLink(obj, null);
}
else
{
obj.REF_STATE = refState;
#if DEBUG
// The PLC link in this object's header
// should already be cleared.
PLCLink *pLinkAddr = getPLCLink(obj);
VTable.Assert(pLinkAddr == null,
@"pLinkAddr == UIntPtr.Zero");
#endif // DEBUG
}
}
private static unsafe void setPLCLink(Object obj, PLCLink *link)
{
((PreHeader)(obj.preHeader)).plcLink = link;
}
private static unsafe void processPLCList()
{
int startTicks = 0;
bool enableGCTiming = VTable.enableGCTiming;
if (enableGCTiming)
{
VTable.enableGCTiming = false;
startTicks = Environment.TickCount;
}
if (VTable.enableGCWatermarks)
{
MemoryAccounting.RecordHeapWatermarks();
}
#if DEBUG
VTable.Assert(firstPLCLink->objAddr == UIntPtr.Zero,
@"firstPLCLink->objAddr == UIntPtr.Zero");
#endif // DEBUG
// Let S be the subgraph of heap objects reachable from
// the PLC list. Decrement counts due to references in S.
for (PLCLink *link = firstPLCLink->next; link != null;
link = link->next)
{
UIntPtr objAddr = link->objAddr;
VTable.Assert(objAddr != UIntPtr.Zero,
@"objAddr != UIntPtr.Zero");
Object obj = Magic.fromAddress(objAddr);
VTable.Assert((obj.REF_STATE &
countingONFlagMask) != 0,
@"(obj.REF_STATE &
countingONFlagMask) != 0");
uint refState = obj.REF_STATE;
if ((refState & markFlagMask) == 0)
{
obj.REF_STATE = refState | markFlagMask;
internalDecrementer.Traverse(objAddr);
}
}
// Objects that now have non-zero counts are those that
// have references external to S incident on them.
// Recompute counts due to reachability from such objects.
for (PLCLink *link = firstPLCLink->next; link != null;
link = link->next)
{
UIntPtr objAddr = link->objAddr;
internalScanner.Traverse(objAddr);
}
// String together objects with reference count
// of zero for reclamation.
internalReclaimer.Initialize();
for (PLCLink *link = firstPLCLink->next; link != null;
link = link->next)
{
UIntPtr objAddr = link->objAddr;
internalReclaimer.Traverse(objAddr);
}
ulong reclaimedBytes = 0;
Object reclaimedObj = internalReclaimer.ReclaimedObjects;
while (reclaimedObj != null)
{
if (VTable.enableGCProfiling)
{
UIntPtr size = ObjectLayout.Sizeof(reclaimedObj);
reclaimedBytes += (ulong)size;
}
Object nextReclaimedObj = getNextLink(reclaimedObj);
SegregatedFreeList.Free(reclaimedObj);
reclaimedObj = nextReclaimedObj;
}
// Recycle the PLC list.
if (firstPLCLink->next != null)
{
PLCLink *lastPLCLink = firstPLCLink;
do
{
lastPLCLink = lastPLCLink->next;
} while (lastPLCLink->next != null);
lastPLCLink->next = plcListChunk;
plcListChunk = firstPLCLink->next;
firstPLCLink->next = null;
}
// Release the memory used up by work lists.
UIntPtrQueue.ReleaseStandbyPages(null);
SegregatedFreeList.RecycleGlobalPages();
SegregatedFreeList.CommitFreedData();
GC.newBytesSinceGC = UIntPtr.Zero;
if (enableGCTiming)
{
int elapsedTicks = Environment.TickCount - startTicks;
System.GC.gcTotalTime += elapsedTicks;
if (System.GC.maxPauseTime < elapsedTicks)
{
System.GC.maxPauseTime = elapsedTicks;
}
System.GC.pauseCount++;
VTable.enableGCTiming = true;
}
if (VTable.enableGCProfiling)
{
if (maxCyclicGarbage < reclaimedBytes)
{
maxCyclicGarbage = reclaimedBytes;
}
totalCyclicGarbage += reclaimedBytes;
cycleCollections++;
}
}
protected static void deallocateObjects
(NonNullReferenceVisitor decrementer)
{
int startTicks = 0;
bool enableGCTiming = VTable.enableGCTiming;
if (enableGCTiming)
{
VTable.enableGCTiming = false;
startTicks = Environment.TickCount;
}
if (VTable.enableGCWatermarks)
{
MemoryAccounting.RecordHeapWatermarks();
}
// Set up a block to deallocate, if one doesn't exist.
if (beingDeallocatedBlock == null &&
delayedDeallocationList != null)
{
beingDeallocatedBlock = delayedDeallocationList;
delayedDeallocationList =
getNextLink(delayedDeallocationList);
delayedDeallocationLength--;
UIntPtr objAddr = Magic.addressOf(beingDeallocatedBlock);
VTable vtable = beingDeallocatedBlock.vtable;
initIncrementalDecrement(objAddr, vtable);
}
// Perform up to a constant number of work chunks on the
// block being deallocated. A "work chunk" is either
// decrementing up to a fixed number of references held in
// an object, decrementing up to a fixed number of slots
// if the object is an array, or reclaiming the object
// after all decrements on its internal contents are done.
for (uint workDone = 0; beingDeallocatedBlock != null &&
workDone < deallocationSpan; workDone++)
{
// Continue work on block.
UIntPtr objAddr = Magic.addressOf(beingDeallocatedBlock);
#if DEBUG
UIntPtr page = PageTable.Page(objAddr);
VTable.Assert(PageTable.IsGcPage(page),
@"PageTable.IsGcPage(page)");
#endif // DEBUG
VTable vtable = beingDeallocatedBlock.vtable;
if (incrementalDecrement(objAddr, vtable,
decrementer) != 0)
{
continue;
}
// All decrements on contained references are over.
Object obj = beingDeallocatedBlock;
VTable.Assert((obj.REF_STATE & RSMasks.refCount) == 0,
@"(obj.REF_STATE & RSMasks.refCount) == 0");
#if DEBUG
PLCLink *plcLinkAddr = GetPLCLink(obj);
VTable.Assert(plcLinkAddr == null,
@"plcLinkAddr == null");
#endif // DEBUG
SegregatedFreeList.Free(obj);
// Set up block to work on next.
beingDeallocatedBlock = delayedDeallocationList;
if (delayedDeallocationList != null)
{
delayedDeallocationList =
getNextLink(delayedDeallocationList);
delayedDeallocationLength--;
objAddr = Magic.addressOf(beingDeallocatedBlock);
vtable = beingDeallocatedBlock.vtable;
initIncrementalDecrement(objAddr, vtable);
}
}
SegregatedFreeList.RecycleGlobalPages();
SegregatedFreeList.CommitFreedData();
GC.newBytesSinceGC = UIntPtr.Zero;
if (enableGCTiming)
{
int elapsedTicks = Environment.TickCount - startTicks;
System.GC.gcTotalTime += elapsedTicks;
if (System.GC.maxPauseTime < elapsedTicks)
{
System.GC.maxPauseTime = elapsedTicks;
}
System.GC.pauseCount++;
VTable.enableGCTiming = true;
}
}