public void ArenaAllocatorTest() { ArenaAllocator allocator = new ArenaAllocator(1000); Assert.AreSame(allocator, Allocator.GetAllocatorByID(allocator.ID)); Assert.IsTrue(Allocator.IsCached(allocator)); int *p = allocator.Allocate <int>(4); for (int i = 0; i < 4; i++) { p[i] = i + 1; } Assert.AreEqual(1, p[0]); Assert.AreEqual(2, p[1]); Assert.AreEqual(3, p[2]); Assert.AreEqual(4, p[3]); p = allocator.Reallocate(p, 6); Assert.AreEqual(1, p[0]); Assert.AreEqual(2, p[1]); Assert.AreEqual(3, p[2]); Assert.AreEqual(4, p[3]); Assert.AreEqual(0, p[4]); Assert.AreEqual(0, p[5]); allocator.Free(p); allocator.Dispose(); Assert.IsFalse(Allocator.IsCached(allocator)); }
/// <summary> /// Initialize GlobalMemoryRegion. /// </summary> /// <param name="globalMemoryRegion"></param> /// <returns></returns> public static GlobalMemoryRegion InitializeMemoryRegion(this GlobalMemoryRegion globalMemoryRegion) { // Initialize properties. // globalMemoryRegion.GlobalMemoryRegionIndex = 1; globalMemoryRegion.RegisteredSettingsAssemblyCount.Store(1); MemoryRegion memoryHeader = globalMemoryRegion.MemoryHeader; MemoryRegionId memoryRegionId = memoryHeader.MemoryRegionId; memoryRegionId.Type = MemoryRegionType.Global; SharedConfigDictionary sharedConfigDictionary = globalMemoryRegion.SharedConfigDictionary; ArenaAllocator allocator = sharedConfigDictionary.Allocator; // Initialize memory allocator. // allocator.InitializeArenaAllocator(memoryHeader, (int)globalMemoryRegion.CodegenTypeSize()); // Initialize shared config dictionary. // sharedConfigDictionary.InitializeSharedConfigDictionary(); return(globalMemoryRegion); }
private static ArenaAllocator GetAllocator(ref ArenaAllocator alloc, uint pageSize, uint pageCount) { if (alloc == null) { alloc = new ArenaAllocator(pageSize, pageCount); } return(alloc); }
/// <summary> /// Allocates the memory for the given type in the shared memory region. /// </summary> /// <typeparam name="T">CodegenProxyType of the allocated object.</typeparam> /// <param name="allocator">Allocator instance.</param> /// <returns></returns> public static T Allocate <T>(this ArenaAllocator allocator) where T : ICodegenProxy, new() { AllocationEntry allocationEntry = allocator.Allocate(default(T).CodegenTypeSize()); T codegenProxy = new T { Buffer = allocationEntry.Buffer + (int)default(AllocationEntry).CodegenTypeSize() }; return(codegenProxy); }
/// <summary> /// Initializes the arena allocator stored in the memory region. /// </summary> /// <param name="allocator"></param> /// <param name="memoryRegion"></param> /// <param name="memoryRegionHeaderSize"></param> public static void InitializeArenaAllocator( this ArenaAllocator allocator, MemoryRegion memoryRegion, int memoryRegionHeaderSize) { // Store offset to the allocator itself. // allocator.OffsetToAllocator = (int)allocator.Buffer.Offset(memoryRegion.Buffer); allocator.EndOffset = (uint)memoryRegion.MemoryRegionSize; allocator.FreeOffset = Utils.Align((uint)memoryRegionHeaderSize, MlosInternal.ArenaAllocator.AllocationAlignment); allocator.AllocationCount = 0; allocator.LastOffset = 0; }
/// <summary> /// Initializes the arena allocator stored in the memory region. /// </summary> /// <param name="allocator"></param> /// <param name="memoryRegion"></param> /// <param name="firstAllocationOffset"></param> public static void InitializeArenaAllocator( this ArenaAllocator allocator, MemoryRegion memoryRegion, int firstAllocationOffset) { // Store offset to the allocator itself. // allocator.OffsetToAllocator = (int)allocator.Buffer.Offset(memoryRegion.Buffer); allocator.FirstAllocationOffset = Utils.Align((uint)firstAllocationOffset, 256); allocator.AllocationBlockSize = (uint)memoryRegion.MemoryRegionSize - allocator.FirstAllocationOffset; allocator.FreeOffset = allocator.FirstAllocationOffset; allocator.AllocationCount = 0; allocator.LastAllocatedOffset = 0; }
/// <summary> /// Allocates the memory in the shared memory region. /// </summary> /// <param name="allocator"></param> /// <param name="size"></param> /// <returns></returns> public static AllocationEntry Allocate(this ArenaAllocator allocator, ulong size) { size += default(AllocationEntry).CodegenTypeSize(); if (allocator.FreeOffset + size >= allocator.AllocationBlockSize + allocator.FirstAllocationOffset) { throw new OutOfMemoryException(); } // Update the address. // uint offset = allocator.FreeOffset; // Update memory region properties. // allocator.FreeOffset += (uint)Utils.Align(size, 64); allocator.AllocationCount++; IntPtr memoryRegionPtr = allocator.Buffer - allocator.OffsetToAllocator; // Update last allocated entry. // if (allocator.LastAllocatedOffset != 0) { AllocationEntry lastAllocationEntry = new AllocationEntry { Buffer = memoryRegionPtr + (int)allocator.LastAllocatedOffset, }; lastAllocationEntry.NextEntryOffset = offset; } // Update current allocated entry. // AllocationEntry allocationEntry = new AllocationEntry { Buffer = memoryRegionPtr + (int)offset, }; allocationEntry.PrevEntryoffset = allocator.LastAllocatedOffset; allocator.LastAllocatedOffset = offset; return(allocationEntry); }
public void Setup() { int AllocatorSize = Bytes * 2; var defaultAlloc = Allocator.Default; if (defaultAlloc == null) { throw new Exception("Null default allocator"); } heapAllocator = DefaultHeapAllocator.Instance; localAllocator = DefaultLocalAllocator.Instance; cAllocator = DefaultCppAllocator.Instance; arenaAllocator = new ArenaAllocator(AllocatorSize); stackAllocator = new StackAllocator(AllocatorSize); fixedPoolAllocator = new FixedMemoryPoolAllocator(10, AllocatorSize); poolAllocator = new MemoryPoolAllocator(AllocatorSize); }
/// <summary> /// Initialize SharedConfigMemoryRegion. /// </summary> /// <param name="sharedConfigMemoryRegion"></param> /// <returns></returns> public static SharedConfigMemoryRegion InitializeMemoryRegion(this SharedConfigMemoryRegion sharedConfigMemoryRegion) { SharedConfigDictionary sharedConfigDictionary = sharedConfigMemoryRegion.SharedConfigDictionary; ArenaAllocator allocator = sharedConfigDictionary.Allocator; MemoryRegion memoryHeader = sharedConfigMemoryRegion.MemoryHeader; MemoryRegionId memoryRegionId = memoryHeader.MemoryRegionId; memoryRegionId.Type = MemoryRegionType.SharedConfig; // Initialize memory allocator. // allocator.InitializeArenaAllocator(sharedConfigMemoryRegion.MemoryHeader, (int)sharedConfigMemoryRegion.CodegenTypeSize()); // Initialize shared config dictionary. // sharedConfigDictionary.InitializeSharedConfigDictionary(); return(sharedConfigMemoryRegion); }
public KMemoryManager(Process Process) { CpuMemory = Process.Memory; Allocator = Process.Device.Memory.Allocator; long CodeRegionSize; long MapRegionSize; long HeapRegionSize; long NewMapRegionSize; long TlsIoRegionSize; int AddrSpaceWidth; AddressSpaceType AddrType = AddressSpaceType.Addr39Bits; if (Process.MetaData != null) { AddrType = (AddressSpaceType)Process.MetaData.AddressSpaceWidth; } switch (AddrType) { case AddressSpaceType.Addr32Bits: CodeRegionStart = 0x200000; CodeRegionSize = 0x3fe00000; MapRegionSize = 0x40000000; HeapRegionSize = 0x40000000; NewMapRegionSize = 0; TlsIoRegionSize = 0; AddrSpaceWidth = 32; break; case AddressSpaceType.Addr36Bits: CodeRegionStart = 0x8000000; CodeRegionSize = 0x78000000; MapRegionSize = 0x180000000; HeapRegionSize = 0x180000000; NewMapRegionSize = 0; TlsIoRegionSize = 0; AddrSpaceWidth = 36; break; case AddressSpaceType.Addr36BitsNoMap: CodeRegionStart = 0x200000; CodeRegionSize = 0x3fe00000; MapRegionSize = 0; HeapRegionSize = 0x80000000; NewMapRegionSize = 0; TlsIoRegionSize = 0; AddrSpaceWidth = 36; break; case AddressSpaceType.Addr39Bits: CodeRegionStart = 0x8000000; CodeRegionSize = 0x80000000; MapRegionSize = 0x1000000000; HeapRegionSize = 0x180000000; NewMapRegionSize = 0x80000000; TlsIoRegionSize = 0x1000000000; AddrSpaceWidth = 39; break; default: throw new InvalidOperationException(); } AddrSpaceStart = 0; AddrSpaceEnd = 1L << AddrSpaceWidth; CodeRegionEnd = CodeRegionStart + CodeRegionSize; MapRegionStart = CodeRegionEnd; MapRegionEnd = CodeRegionEnd + MapRegionSize; HeapRegionStart = MapRegionEnd; HeapRegionEnd = MapRegionEnd + HeapRegionSize; NewMapRegionStart = HeapRegionEnd; NewMapRegionEnd = HeapRegionEnd + NewMapRegionSize; TlsIoRegionStart = NewMapRegionEnd; TlsIoRegionEnd = NewMapRegionEnd + TlsIoRegionSize; CurrentHeapAddr = HeapRegionStart; if (NewMapRegionSize == 0) { NewMapRegionStart = AddrSpaceStart; NewMapRegionEnd = AddrSpaceEnd; } Blocks = new LinkedList <KMemoryBlock>(); long AddrSpacePagesCount = (AddrSpaceEnd - AddrSpaceStart) / PageSize; InsertBlock(AddrSpaceStart, AddrSpacePagesCount, MemoryState.Unmapped); }