public bool AllocateBuffer(ulong Size)
{
unsafe {
// Allocate the memory indicated as parameter, as nonGC
#if SINGULARITY_KERNEL
UIntPtr pages = Microsoft.Singularity.Memory.MemoryManager.PagesFromBytes(Size);
bufferMemory = (byte *)Microsoft.Singularity.Memory.MemoryManager.KernelAllocate(
pages, null, 0, System.GCs.PageType.NonGC).ToPointer();
// Allocation at page granularity. Preserve the actual size of the buffer
BufferSize = (ulong)pages * Microsoft.Singularity.Memory.MemoryManager.PageSize;
#else // !SINGULARITY_KERNEL
bufferMemory = (byte *)PageTableService.Allocate(Size);
BufferSize = Size;
#endif //SINGULARITY_KERNEL
if (bufferMemory == null)
{
BufferSize = 0;
return(false);
}
}
return(true);
}
internal static unsafe void Initialize()
{
Tracing.Log(Tracing.Debug, "Initialize.");
processTag = PageTableService.GetProcessTag();
baseAddr = PageTableService.GetBaseAddress();
pageTableCount = PageTableService.GetPageCount();
limitAddr = baseAddr + (pageTableCount << PageBits);
halPageDescriptor = PageTableService.GetPageTable();
}
internal static bool QueryMemory(UIntPtr queryAddr,
out UIntPtr regionAddr,
out UIntPtr regionSize)
{
#if SINGULARITY_KERNEL
PageType type = Sing_MemoryManager.KernelQuery(
queryAddr, out regionAddr, out regionSize);
return(type != PageType.Unknown);
#elif SINGULARITY_PROCESS
return(PageTableService.Query(queryAddr, out regionAddr, out regionSize));
#endif
}
internal static void FreeMemory(UIntPtr startAddr, UIntPtr size)
{
#if SINGULARITY_KERNEL
DebugStub.Assert(Sing_MemoryManager.IsPageAligned(size));
Sing_MemoryManager.KernelFree(
startAddr, Sing_MemoryManager.PagesFromBytes(size),
Process.kernelProcess);
#elif SINGULARITY_PROCESS
VTable.Assert((size & PageTable.PageMask) == 0);
PageTableService.Free(startAddr, size);
#endif
}
// Initialization, prior to attempting to set this profiler into the GC. It's
// inappropriate to do this stuff inside a constructor.
internal void Initialize(ulong Size, ulong Flags)
{
options = Flags;
typeTable = new Hashtable();
stackTable = new Hashtable();
funcTable = new Hashtable();
stackEips = new UIntPtr[stackSize];
stackNos = new uint[stackSize];
generations = new int[maxGeneration];
functionsIDs = new uint[stackSize];
Buffer = new ProfilerBuffer();
tempGCBuffer = new UIntPtr[tempBufferSize];
tempGCBufferEntries = 0;
#if LEGACY_GCTRACING
bufferSize = Size;
unsafe {
// Allocate the memory indicated as parameter, as nonGC
#if SINGULARITY_KERNEL
UIntPtr pages = Microsoft.Singularity.Memory.MemoryManager.PagesFromBytes(bufferSize);
bufferMemory = (byte *)Microsoft.Singularity.Memory.MemoryManager.KernelAllocate(
pages, null, 0, System.GCs.PageType.NonGC).ToPointer();
#else // !SINGULARITY_KERNEL
bufferMemory = (byte *)PageTableService.Allocate(bufferSize);
#endif //SINGULARITY_KERNEL
if (bufferMemory != null)
{
// When we set this, we are no longer single-threaded:
ProfilerBuffer.SetupBuffer(bufferMemory, bufferSize);
this.enabled = true;
}
}
#else // LEGACY_GCTRACING
typeSource = GCTypeSource.Create("GC.TypeDefinitions", (uint)Size, options);
EventSource = GCEventSource.Create("GC.Events", (uint)Size, options);
if ((typeSource == null) || (EventSource == null))
{
typeSource = null;
EventSource = null;
this.enabled = false;
}
else
{
TypeStorageHandle = typeSource.Storage.GetHandle();
StorageHandle = EventSource.Storage.GetHandle();
this.enabled = true;
}
#endif // LEGACY_GCTRACING
}
public void Finish(long iterations)
{
endCycleCount = unchecked ((long)Processor.CycleCount);
#if X64_PERF
x64_p0 = Processor.ReadPmc(0);
x64_p1 = Processor.ReadPmc(1);
x64_p2 = Processor.ReadPmc(2);
x64_p3 = Processor.ReadPmc(3);
#endif
endInterruptCount = ProcessService.GetKernelInterruptCount();
endSwitchCount = ProcessService.GetContextSwitchCount();
endKernelGcCount = ProcessService.GetKernelGcCount();
int collectorCount;
long collectorMillis;
long collectorBytes;
GC.PerformanceCounters(out collectorCount,
out collectorMillis,
out collectorBytes);
endProcessGcCount = collectorCount;
ulong allocatedCount;
ulong allocatedBytes;
ulong freedCount;
ulong freedBytes;
PageTableService.GetUsageStatistics(out allocatedCount,
out allocatedBytes,
out freedCount,
out freedBytes);
endAllocatedCount = allocatedCount;
endAllocatedBytes = allocatedBytes;
endFreedCount = freedCount;
endFreedBytes = freedBytes;
ulong stackGets;
ulong stackRets;
StackService.GetUsageStatistics(out stackGets,
out stackRets);
endStackGets = stackGets;
endStackRets = stackRets;
if (!AtRing3)
{
Processor.RestoreLocalPreemption(disabled);
}
this.iterations = iterations;
}
public static int Main()
{
#if TEST_CONSOLE
int i = 10;
long l = 100;
byte b = 1;
bool o = true;
#endif
DebugStub.Print("Hello from NullTest::Main\n");
#if TEST_CONSOLE
DebugStub.Print(b);
DebugStub.Print("\n");
DebugStub.Print(i);
DebugStub.Print("\n");
DebugStub.Print(l);
DebugStub.Print("\n");
DebugStub.Print(o);
DebugStub.Print("\n");
#endif
#if TEST_MEMORY_ABI
uint tag = PageTableService.GetProcessTag();
DebugStub.Print("Process Tag: ");
DebugStub.Print((ulong)tag);
DebugStub.Print("\n");
uint pages = PageTableService.GetPageCount();
DebugStub.Print("Pages: ");
DebugStub.Print(pages);
DebugStub.Print("\n");
uint addr = PageTableService.Allocate(0x1000);
DebugStub.Print("Allocation: ");
DebugStub.Print((ulong)addr);
DebugStub.Print("\n");
Probe(addr);
addr = 1;
for (i = 0; i < 20 && addr != 0 && addr < 0xc0000000; i++)
{
addr = Probe(addr);
}
#endif // TEST_MEMORY_ABI
#if TEST_STACK_ABI
Test1(1);
#endif // TEST_STACK_ABI
return(0);
}
public static int Main()
{
int i = 10;
long l = 100;
byte b = 1;
bool o = true;
DebugService.Print('H');
DebugService.Print(b);
DebugService.Print(',');
DebugService.Print(i);
DebugService.Print(',');
DebugService.Print(l);
DebugService.Print(',');
DebugService.Print(o);
DebugService.Print('\n');
#if TEST_MEMORY_ABI
uint tag = PageTableService.GetProcessTag();
DebugService.Print('p');
DebugService.Print((ulong)tag);
DebugService.Print('\n');
uint pages = PageTableService.GetPageCount();
DebugService.Print('n');
DebugService.Print(pages);
DebugService.Print('\n');
uint addr = PageTableService.Allocate(0x1000);
DebugService.Print('a');
DebugService.Print((ulong)addr);
DebugService.Print('\n');
Probe(addr);
addr = 1;
for (i = 0; i < 20 && addr != 0 && addr < 0xc0000000; i++)
{
addr = Probe(addr);
}
#endif // TEST_MEMORY_ABI
#if TEST_STACK_ABI
Test1(1);
#endif // TEST_STACK_ABI
return(999);
}
public static uint Probe(uint addr)
{
uint begin;
uint bytes;
bool used = PageTableService.Query(addr, out begin, out bytes);
DebugService.Print(' ');
DebugService.Print((ulong)begin);
DebugService.Print('.');
DebugService.Print((ulong)begin + bytes);
DebugService.Print(' ');
if (used)
{
DebugService.Print('u');
}
DebugService.Print('\n');
return(begin + bytes);
}
public static uint Probe(uint addr)
{
uint begin;
uint bytes;
bool used = PageTableService.Query(addr, out begin, out bytes);
DebugStub.Print(" ");
DebugStub.Print((ulong)begin);
DebugStub.Print("..");
DebugStub.Print((ulong)begin + bytes);
DebugStub.Print(" ");
if (used)
{
DebugStub.Print("[used]");
}
DebugStub.Print("\n");
return(begin + bytes);
}
//////////////////////////////////// Allocation and Free Routines.
//
// Allocation is optimized for the case where an allocation starts
// with a relatively small amount of memory and grows over time.
// This is exactly the behavior exhibited by stacks and GC heaps.
//
// The allocation strategy also works well for large initial
// allocations. The strategy would be very inefficient if a very
// large number of small, completely independent allocations are
// made.
//
// AllocateMemory(size) performs an initial allocation.
// AllocateMemory(startAddr, size) performs growing allocations.
//
internal static unsafe UIntPtr AllocateMemory(UIntPtr size)
{
VTable.Assert(PageTable.PageAligned(size));
#if SINGULARITY_KERNEL
UIntPtr addr = Sing_MemoryManager.KernelAllocate(
Sing_MemoryManager.PagesFromBytes(size),
Process.kernelProcess, 0, PageType.Unknown);
#elif SINGULARITY_PROCESS
UIntPtr addr = PageTableService.Allocate(size);
#endif
#if SINGULARITY_KERNEL
Kernel.Waypoint((int)size);
Kernel.Waypoint(811);
#endif // SINGULARITY_KERNEL
if (addr != UIntPtr.Zero)
{
Util.MemClear(addr, size);
}
return(addr);
}
internal static unsafe bool AllocateMemory(UIntPtr startAddr,
UIntPtr size)
{
VTable.Deny(inAllocator);
inAllocator = true;
VTable.Assert(PageTable.PageAligned(startAddr));
VTable.Assert(PageTable.PageAligned(size));
#if SINGULARITY_KERNEL
UIntPtr addr = Sing_MemoryManager.KernelExtend(
startAddr, Sing_MemoryManager.PagesFromBytes(size),
Process.kernelProcess, PageType.Unknown);
#elif SINGULARITY_PROCESS
UIntPtr addr = PageTableService.AllocateExtend(startAddr, size);
#endif
inAllocator = false;
if (addr != UIntPtr.Zero)
{
Util.MemClear(addr, size);
return(true);
}
return(false);
}
public void Start()
{
if (!AtRing3)
{
disabled = Processor.DisableLocalPreemption();
}
int collectorCount;
long collectorMillis;
long collectorBytes;
GC.PerformanceCounters(out collectorCount,
out collectorMillis,
out collectorBytes);
ulong stackGets;
ulong stackRets;
StackService.GetUsageStatistics(out stackGets,
out stackRets);
begStackGets = stackGets;
begStackRets = stackRets;
ulong allocatedCount;
ulong allocatedBytes;
ulong freedCount;
ulong freedBytes;
PageTableService.GetUsageStatistics(out allocatedCount,
out allocatedBytes,
out freedCount,
out freedBytes);
begAllocatedCount = allocatedCount;
begAllocatedBytes = allocatedBytes;
begFreedCount = freedCount;
begFreedBytes = freedBytes;
begInterruptCount = ProcessService.GetKernelInterruptCount();
begSwitchCount = ProcessService.GetContextSwitchCount();
begKernelGcCount = ProcessService.GetKernelGcCount();
begProcessGcCount = collectorCount;
#if x64_PERF
// Set up for perf counting
if (!AtRing3)
{
// Reset the performance counters to what we're interested in.
Reset(0, PerfEvtSel.COUNT | PerfEvtSel.CyclesNotHalted);
Reset(1, PerfEvtSel.COUNT | PerfEvtSel.RetiredInstructions);
Reset(2, PerfEvtSel.COUNT | PerfEvtSel.RetiredBranchInstructions);
Reset(3, PerfEvtSel.COUNT | PerfEvtSel.RequestsToL2Cache | 0x400);
}
else
{
// We're not allowed to reset the perf counters, so take note
// of their current values; we will subtract from this later.
x64_i0 = Processor.ReadPmc(0);
x64_i1 = Processor.ReadPmc(1);
x64_i2 = Processor.ReadPmc(2);
x64_i3 = Processor.ReadPmc(3);
}
#endif
begCycleCount = unchecked ((long)Processor.CycleCount);
}
