internal static unsafe void MarkThreadStack(Thread thread)
{
int stackVariable;
UIntPtr stackBase = PageTable.PagePad(new UIntPtr(&stackVariable));
CallStack.SetStackBase(thread, stackBase);
UIntPtr topPageAddr =
PageTable.PageAlign(CallStack.StackBase(thread) - 1);
SetStackPages(topPageAddr, CallStack.StackBase(thread), thread);
UIntPtr regionAddr, regionSize;
bool fUsed = MemoryManager.QueryMemory(topPageAddr,
out regionAddr,
out regionSize);
VTable.Assert(fUsed);
SetStackPages(regionAddr, topPageAddr, thread);
}
internal static unsafe void ClearThreadStack(Thread thread)
{
short threadIndex = (short)thread.threadIndex;
UIntPtr endPage = PageTable.Page(CallStack.StackBase(thread));
UIntPtr startPage = endPage - 1;
VTable.Assert(PageTable.IsStackPage(PageTable.Type(startPage)));
VTable.Assert(PageTable.Extra(startPage) == threadIndex);
while (startPage > 0 &&
PageTable.IsStackPage(PageTable.Type(startPage - 1)) &&
PageTable.Extra(startPage - 1) == threadIndex)
{
startPage--;
}
UIntPtr startAddr = PageTable.PageAddr(startPage);
UIntPtr size = PageTable.RegionSize(endPage - startPage);
SetUnallocatedPages(startAddr, size);
}
internal unsafe static void ReportStackDetails()
{
VTable.DebugPrint("\nStack details:\n");
VTable.DebugPrint("\tTotal number of reserved pages: {0}",
__arglist(TotalNumPages(PageType.Stack)));
for (int i = 0; i < Thread.threadTable.Length; i++)
{
traceablePtrs.Initialize();
traceablePinnedPtrs.Initialize();
Thread t = Thread.threadTable[i];
if (t == null)
{
continue;
}
uint numStackFrames =
CallStack.ScanStack(t, traceablePtrs,
traceablePinnedPtrs);
VTable.DebugPrint("\n\tThread: {0}",
__arglist(i));
VTable.DebugPrint("\n\t\tStack frame count: {0}",
__arglist(numStackFrames));
VTable.DebugPrint("\n\t\tManaged ptrs to static data: {0}",
__arglist
(traceablePtrs.managedPtrsToStaticData));
VTable.DebugPrint("\n\t\tManaged ptrs to stack: {0}",
__arglist(traceablePtrs.managedPtrsToStack));
VTable.DebugPrint("\n\t\tExterior managed heap ptrs: {0}",
__arglist
(traceablePtrs.exteriorManagedHeapPtrs));
VTable.DebugPrint("\n\t\tInterior managed heap ptrs: {0}",
__arglist
(traceablePtrs.interiorManagedHeapPtrs));
#if !SINGULARITY
UIntPtr stackTop = (UIntPtr)CallStack.StackMarker(t);
uint stackSize = 0;
if (stackTop != UIntPtr.Zero)
{
VTable.Assert(CallStack.StackBase(t) > stackTop,
@"t.asmStackBase > stackTop");
stackSize = (uint)(CallStack.StackBase(t) - stackTop);
}
VTable.DebugPrint("\n\t\tApprox. stack size: {0}B",
__arglist(stackSize));
#endif
// REVIEW: Why are these here?
VTable.Assert(traceablePinnedPtrs.
managedPtrsToStaticData == 0,
@"traceablePinnedPtrs.
managedPtrsToStaticData == 0");
VTable.Assert(traceablePinnedPtrs.
managedPtrsToStack == 0,
@"traceablePinnedPtrs.
managedPtrsToStack == 0");
VTable.DebugPrint("\n\t\tPinned managed heap ptrs: {0}",
__arglist
(traceablePinnedPtrs.exteriorManagedHeapPtrs +
traceablePinnedPtrs.interiorManagedHeapPtrs));
}
VTable.DebugPrint("\n");
}
internal override void CollectStopped(int currentThreadIndex,
int generation)
{
#if SINGULARITY
#if DEBUG
#if THREAD_TIME_ACCOUNTING
UIntPtr preGcTotalBytes = SegregatedFreeList.TotalBytes;
#endif
DebugStub.WriteLine("~~~~~ Start MarkSweep Cleanup [data={0:x8}, pid={1:x3}]",
__arglist(SegregatedFreeList.TotalBytes,
PageTable.processTag >> 16));
#endif
#if SINGULARITY_KERNEL
#if THREAD_TIME_ACCOUNTING
TimeSpan ticks = Thread.CurrentThread.ExecutionTime;
TimeSpan ticks2 = SystemClock.KernelUpTime;
#else
TimeSpan ticks = SystemClock.KernelUpTime;
#endif
#elif SINGULARITY_PROCESS
#if THREAD_TIME_ACCOUNTING
TimeSpan ticks = ProcessService.GetThreadTime();
TimeSpan ticks2 = ProcessService.GetUpTime();
#else
TimeSpan ticks = ProcessService.GetUpTime();
#endif
#endif
#endif
int before = 0;
if (VTable.enableGCTiming)
{
before = Environment.TickCount;
}
if (GC.IsProfiling)
{
GcProfiler.NotifyPreGC(MinGeneration);
// non-generational collector, so pretend Gen0
// Calls like ResurrectCandidates below can cause
// allocations and thus, potentially, profiler
// notifications. However, at that time the heap is
// damaged in the sense that VPtrs have bits OR-ed in
// for object marking. We do not want to accept
// profiling during this window.
//
// There is no synchronization issue with setting this
// flag because it will only be consulted by the
// thread that sets and resets it.
HeapDamaged = true;
}
// 1) Mark the live objects
CollectorStatistics.Event(GCEvent.TraceStart);
#if !VC
TryAllManager.PreGCHookTryAll();
#endif
MultiUseWord.PreGCHook(false /* don't use shadows */);
Finalizer.PrepareCollectFinalizers();
int countThreads =
CallStack.ScanStacks(threadMarkReferenceVisitor,
threadMarkReferenceVisitor);
Thread.VisitBootstrapData(markAndProcessReferenceVisitor);
#if SINGULARITY_KERNEL
Kernel.VisitSpecialData(markAndProcessReferenceVisitor);
#endif
MultiUseWord.VisitStrongRefs(markAndProcessReferenceVisitor,
false /* Don't use shadows */);
#if !VC
TryAllManager.VisitStrongRefs(markAndProcessReferenceVisitor);
#endif
StaticData.ScanStaticData(markAndProcessReferenceVisitor);
CollectorStatistics.Event(GCEvent.TraceSpecial);
WeakReference.Process(updateReferenceVisitor, true, true);
Finalizer.ResurrectCandidates(updateReferenceVisitor,
markAndProcessReferenceVisitor, true);
markReferenceVisitor.Cleanup();
UnmanagedPageList.ReleaseStandbyPages();
// 2) Sweep the garbage objects
int afterTrace = 0;
if (VTable.enableGCTiming)
{
afterTrace = Environment.TickCount;
}
CollectorStatistics.Event(GCEvent.SweepStart, TotalMemory);
WeakReference.Process(updateReferenceVisitor, true, false);
MultiUseWord.VisitWeakRefs(updateReferenceVisitor,
false /* Don't use shadows */);
#if !VC
TryAllManager.VisitWeakRefs(updateReferenceVisitor);
#endif
SegregatedFreeList.VisitAllObjects(sweepVisitor);
SegregatedFreeList.RecycleGlobalPages();
SegregatedFreeList.CommitFreedData();
CollectorStatistics.Event(GCEvent.SweepSpecial);
MultiUseWord.PostGCHook();
if (GC.IsProfiling)
{
HeapDamaged = false;
// Allocations may occur inside the PostGCHook. Hopefully a
// sufficiently limited quantity that we don't recursively
// trigger a GC.
GcProfiler.NotifyPostGC(ProfileRoots, ProfileObjects);
}
Finalizer.ReleaseCollectFinalizers();
#if !VC
TryAllManager.PostGCHookTryAll();
#endif
CollectorStatistics.Event(GCEvent.CollectionComplete,
TotalMemory);
if (VTable.enableGCTiming)
{
int after = Environment.TickCount;
numCollections++;
traceTime += (afterTrace - before);
sweepTime += (after - afterTrace);
}
// 3) Determine a new collection trigger
UIntPtr testTrigger = (UIntPtr)this.TotalMemory >> 2;
UIntPtr minTrigger = (UIntPtr)MinTrigger;
UIntPtr maxTrigger = (UIntPtr)MaxTrigger;
collectionTrigger =
(testTrigger > minTrigger) ?
(testTrigger < maxTrigger ?
testTrigger : maxTrigger) : minTrigger;
#if SINGULARITY
#if SINGULARITY_KERNEL
#if THREAD_TIME_ACCOUNTING
int procId = Thread.CurrentProcess.ProcessId;
ticks = Thread.CurrentThread.ExecutionTime - ticks;
ticks2 = SystemClock.KernelUpTime - ticks2;
#else
ticks = SystemClock.KernelUpTime - ticks;
#endif
//Thread.CurrentProcess.SetGcPerformanceCounters(ticks, (long) SegregatedFreeList.TotalBytes);
#elif SINGULARITY_PROCESS
#if THREAD_TIME_ACCOUNTING
ushort procId = ProcessService.GetCurrentProcessId();
ticks = ProcessService.GetThreadTime() - ticks;
ticks2 = ProcessService.GetUpTime() - ticks2;
#else
ticks = ProcessService.GetUpTime() - ticks;
#endif
//ProcessService.SetGcPerformanceCounters(ticks, (long) SegregatedFreeList.TotalBytes);
#endif
#if DEBUG
#if THREAD_TIME_ACCOUNTING
DebugStub.WriteLine("~~~~~ Finish MarkSweep Cleanup [data={0:x8}, diff={7:x8} pid={1:x3}, ms(Thread)={2:d6}, ms(System)={3:d6}, thds={4}, procId={5}, tid={6}]",
__arglist(SegregatedFreeList.TotalBytes,
PageTable.processTag >> 16,
ticks.Milliseconds,
ticks2.Milliseconds,
countThreads,
procId,
Thread.GetCurrentThreadIndex(),
preGcTotalBytes - SegregatedFreeList.TotalBytes
));
#else
DebugStub.WriteLine("~~~~~ Finish MarkSweep Cleanup [data={0:x8}, pid={1:x3}, ms={2:d6}, thds={3}]",
__arglist(SegregatedFreeList.TotalBytes,
PageTable.processTag >> 16,
ticks.Milliseconds,
countThreads));
#endif
#endif
#endif
}
void Verify(NonNullReferenceVisitor threadReferenceVisitor,
Thread thread)
{
CallStack.ScanStack(thread, threadReferenceVisitor,
threadReferenceVisitor);
}
internal override void CollectGeneration(int generation,
UIntPtr generationPageCount)
{
VTable.Assert(IsValidGeneration(generation));
// 1) Mark the live objects
CollectorStatistics.Event(GCEvent.TraceStart);
MultiUseWord.PreGCHook(true /* use shadows */);
Finalizer.PrepareCollectFinalizers();
CallStack.ScanStacks(registerThreadReferenceVisitor,
registerPinnedReferenceVisitor);
registerThreadReferenceVisitor.ForwardReferences();
if (generation < (int)MAX_GENERATION)
{
// These calls must be done early, as they rely on the
// contents of Thread.threadTable being intact.
installedRemSet.Clean();
installedRemSet.Uniquify();
this.ScanRemSet((PageType)generation);
}
// Process runtime data that is allocated from SystemMemory
Thread.VisitBootstrapData(markReferenceVisitor);
#if SINGULARITY_KERNEL
Kernel.VisitSpecialData(markReferenceVisitor);
#endif
MultiUseWord.VisitStrongRefs(markReferenceVisitor,
true /* use shadows */);
StaticData.ScanStaticData(markReferenceVisitor);
CollectorStatistics.Event(GCEvent.TraceSpecial);
WeakReference.Process(forwardReferenceVisitor, false, true);
Finalizer.ResurrectCandidates(forwardReferenceVisitor,
markReferenceVisitor,
false);
markReferenceVisitor.Cleanup();
// 2) Forward pointers and compact the live objects
CollectorStatistics.Event(GCEvent.SweepStart, TotalMemory);
WeakReference.Process(forwardReferenceVisitor, false, false);
MultiUseWord.VisitWeakRefs(forwardReferenceVisitor,
true /* use shadows */);
UIntPtr oldAllocPtr;
UIntPtr newLimit = this.ForwardReferences((PageType)generation,
out oldAllocPtr);
this.CompactHeapObjects(oldAllocPtr);
#if SINGULARITY
Thread.UpdateAfterGC();
#endif
Thread currentThread = Thread.threadTable[collectorThreadIndex];
#if SINGULARITY_KERNEL
Kernel.UpdateAfterGC(currentThread);
#endif
CallStack.ScanStacks(updateThreadReferenceVisitor,
updateThreadReferenceVisitor);
this.CompactPhaseCleanup(currentThread,
(PageType)generation,
newLimit);
// Resetting the GC state
CollectorStatistics.Event(GCEvent.SweepSpecial);
installedRemSet.Reset();
MultiUseWord.PostGCHook();
Finalizer.ReleaseCollectFinalizers();
CollectorStatistics.Event(GCEvent.CollectionComplete, TotalMemory);
}
internal override void CollectGeneration(int generation,
UIntPtr generationPageCount)
{
UIntPtr fromSpacePageCountTotal = UIntPtr.Zero;
for (int i = MinGeneration; i <= generation; i++)
{
fromSpacePageCountTotal += fromSpacePageCounts[i];
}
PageType maxDestGeneration = (generation < (int)MAX_GENERATION)
? (PageType)(generation + 1)
: MAX_GENERATION;
// The real work: find the roots, copy reachable objects
CollectorStatistics.Event(GCEvent.ComputeRootSet);
#if !VC
TryAllManager.PreGCHookTryAll();
#endif
bool onlyNew = false;
if (generation == (int)nurseryGeneration)
{
onlyNew = true;
}
MultiUseWord.PreGCHook(false, /* don't use shadows */
onlyNew /* only scan new EMUs */);
Finalizer.PrepareCollectFinalizers();
CallStack.ScanStacks(null, pinnedReferenceVisitor);
pinnedReferenceVisitor.ProcessPinnedPages(generalReferenceVisitor);
CallStack.ScanStacks(threadReferenceVisitor, null);
Thread.VisitBootstrapData(generalReferenceVisitor);
#if SINGULARITY
Thread.UpdateAfterGC();
#endif
Thread currentThread = Thread.threadTable[collectorThreadIndex];
#if SINGULARITY_KERNEL
Kernel.VisitSpecialData(generalReferenceVisitor);
Kernel.UpdateAfterGC(currentThread);
#endif
MultiUseWord.VisitStrongRefs(generalReferenceVisitor,
false /* Don't use shadows */);
#if !VC
TryAllManager.VisitStrongRefs(generalReferenceVisitor);
#endif
StaticData.ScanStaticData(generalReferenceVisitor);
if ((PageType)generation < MAX_GENERATION)
{
installedRemSet.Clean();
this.ScanRemSet((PageType)generation);
}
installedRemSet.Reset();
CollectorStatistics.Event(GCEvent.TraceStart);
this.ScanAndCopy(maxDestGeneration);
CollectorStatistics.Event(GCEvent.TraceSpecial);
WeakReference.Process(forwardOnlyReferenceVisitor, true, true);
Finalizer.ResurrectCandidates(forwardOnlyReferenceVisitor,
generalReferenceVisitor,
true);
this.ScanAndCopy(maxDestGeneration);
WeakReference.Process(forwardOnlyReferenceVisitor, true, false);
MultiUseWord.VisitWeakRefs(forwardOnlyReferenceVisitor,
false /* Don't use shadows */);
#if !VC
TryAllManager.VisitWeakRefs(forwardOnlyReferenceVisitor);
#endif
CollectorStatistics.Event(GCEvent.CollectionComplete);
// Clean up the auxiliary data structures
for (int i = MinGeneration + 1; i <= (int)maxDestGeneration; i++)
{
copyScanners[i].Cleanup();
}
UnmanagedPageList.ReleaseStandbyPages();
pinnedReferenceVisitor.CleanPinnedPages();
MultiUseWord.PostGCHook(onlyNew);
Finalizer.ReleaseCollectFinalizers();
#if !VC
TryAllManager.PostGCHookTryAll();
#endif
}
