internal static void AllThreadRelease(int currentThreadIndex)
{
for (int i = 0; i < Thread.threadTable.Length; i++)
{
#if SINGULARITY_KERNEL
if (Scheduler.IsIdleThread(i))
{
continue;
}
#endif
if (i == currentThreadIndex)
{
if (Transitions.HasGCRequest(i))
{
Transitions.ClearGCRequest(i);
}
}
else if (Transitions.UnderGCControl(i))
{
Transitions.ReleaseGCControl(i);
}
// Signal all threads to ensure that the GC process didn't
// accidentally "gobble" an event signal that was meant for
// something else.
if (Thread.threadTable[i] != null)
{
Thread.SignalGCEvent(i);
}
}
}
// To be called when a thread is terminated/terminating
internal static void DeadThreadNotification(int deadThreadIndex)
{
VTable.Assert(Thread.threadTable[deadThreadIndex] == null);
VTable.Assert(InDormantState(deadThreadIndex));
if (Transitions.HasGCRequest(deadThreadIndex))
{
GC.ThreadDormantGCNotification(deadThreadIndex);
}
}
internal static void AllThreadRendezvous(int currentThreadIndex)
{
Transitions.MakeGCRequests(currentThreadIndex);
for (int i = 0; i < Thread.threadTable.Length; i++)
{
if (Thread.threadTable[i] == null ||
i == currentThreadIndex)
{
continue;
}
CollectorStatistics.Event(GCEvent.StopThread, i);
while (!Transitions.TakeGCControl(i) &&
!Transitions.UnderGCControl(i) &&
Transitions.HasGCRequest(i) &&
Thread.threadTable[i] != null)
{
// NOTE: there is no code in this loop that could
// cause a signal on an event to be consumed.
Thread.WaitForGCEvent(currentThreadIndex);
}
}
}
private void PerformCollection(int currentThreadIndex,
int generation)
{
// Clear the GCRequest bit (if necessary) before doing
// anything that could cause a state transition.
if (Transitions.HasGCRequest(currentThreadIndex))
{
Transitions.ClearGCRequest(currentThreadIndex);
}
int startTicks = 0;
bool enableGCTiming = VTable.enableGCTiming;
if (enableGCTiming || VTable.enableFinalGCTiming)
{
VTable.enableGCTiming = false;
startTicks = Environment.TickCount;
if (enableGCTiming)
{
VTable.DebugPrint("[GC start: {0} bytes]\n",
__arglist(TotalMemory));
}
}
#if SINGULARITY
Tracing.Log(Tracing.Debug, "GC start");
#endif
CollectorStatistics.Event(GCEvent.StopTheWorld);
CurrentPhase = StopTheWorldPhase.Synchronizing;
StopTheWorld();
CurrentPhase = StopTheWorldPhase.SingleThreaded;
StartGCCycle();
#if SINGULARITY
long preGcMemoryUsage = GC.GetTotalMemory(false);
#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 //singularity
#if SINGULARITY_KERNEL
bool iflag = Processor.DisableInterrupts();
// Disable interrupts on other CPU's
MpExecution.StopProcessorsForGC();
#endif
#if SINGULARITY
ulong beg = Isa.GetCycleCount();
#endif
// Preparation
GC.allocationGCInhibitCount++;
// Verify the heap before GC
if (VTable.enableGCVerify)
{
this.VerifyHeap(true);
}
// Invoke the chosen collector
#if SINGULARITY
Monitoring.Log(Monitoring.Provider.GC,
(ushort)GarbageCollectorEvent.StartCollection);
#endif
this.CollectStopped(collectorThreadIndex, generation);
#if SINGULARITY
Monitoring.Log(Monitoring.Provider.GC,
(ushort)GarbageCollectorEvent.EndCollection);
#endif
// Verify the heap after GC
if (VTable.enableGCVerify)
{
this.VerifyHeap(false);
}
if (VTable.enableGCAccounting)
{
MemoryAccounting.Report(GC.gcType);
}
// Cleanup
CollectorStatistics.Event(GCEvent.ResumeTheWorld);
GC.allocationGCInhibitCount--;
CurrentPhase = StopTheWorldPhase.Idle;
#if SINGULARITY
long postGcMemoryUsage = GC.GetTotalMemory(false);
#endif
if (enableGCTiming || VTable.enableFinalGCTiming)
{
int elapsedTicks = Environment.TickCount - startTicks;
BaseCollector.RegisterPause(elapsedTicks);
if (enableGCTiming)
{
VTable.DebugPrint("[GC end : {0} bytes, {1} ms]\n",
__arglist(TotalMemory, elapsedTicks));
VTable.enableGCTiming = true;
}
}
if (VTable.enableGCProfiling)
{
ulong totalMemory = (ulong)GC.GetTotalMemory(false);
this.RegisterHeapSize(totalMemory);
}
ResumeTheWorld();
collectorThreadIndex = -1;
#if SINGULARITY
Tracing.Log(Tracing.Debug, "GC stop");
long pagesCollected = preGcMemoryUsage - postGcMemoryUsage;
#if SINGULARITY_KERNEL
#if THREAD_TIME_ACCOUNTING
int procId = Thread.CurrentProcess.ProcessId;
ticks = Thread.CurrentThread.ExecutionTime - ticks;
ticks2 = SystemClock.KernelUpTime - ticks2;
Process.kernelProcess.SetGcPerformanceCounters(ticks, (long)pagesCollected);
#else
ticks = SystemClock.KernelUpTime - ticks;
#endif
Thread.CurrentProcess.SetGcPerformanceCounters(ticks, (long)pagesCollected);
#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)pagesCollected);
#endif
#if DEBUG
#if THREAD_TIME_ACCOUNTING
DebugStub.WriteLine("~~~~~ StopTheWorld [collected pages={0:x8}, pid={1:x3}, ms(Thread)={2:d6}, ms(System)={3:d6}, procId={4}, tid={5}]",
__arglist(pagesCollected,
PageTable.processTag >> 16,
ticks.Milliseconds,
ticks2.Milliseconds,
procId,
Thread.GetCurrentThreadIndex()
));
#endif
#endif
#endif
#if SINGULARITY
DebugStub.AddToPerfCounter(GC.perfCounter, Isa.GetCycleCount() - beg);
#endif
#if SINGULARITY_KERNEL
// Resume interrupts on other CPU's
MpExecution.ResumeProcessorsAfterGC();
Processor.RestoreInterrupts(iflag);
#endif
}