public void Dispose()
{
for (var i = m_blocks.Length - 1; i >= 0; --i)
{
AllocatorManager.Free(m_handle, (void *)m_blocks[i]);
}
m_allocations.Dispose();
m_blocks.Dispose();
}
public void CustomAllocatorNativeListWorksWithoutHandles()
{
AllocatorManager.Initialize();
var allocator = AllocatorManager.Persistent;
var list = NativeList <byte> .New(100, ref allocator);
list.Dispose(ref allocator);
AllocatorManager.Shutdown();
}
public void Dispose()
{
if (ptr != null)
{
AllocatorManager.Free(allocator, ptr);
allocator = Allocator.Invalid;
ptr = null;
length = 0;
UnsafeList.Destroy(emptyIndices);
}
}
/// <summary>
/// Destroys list.
/// </summary>
/// <param name="listData">Container to destroy.</param>
public static void Destroy(UnsafePtrList *listData)
{
UnsafeList.CheckNull(listData);
var allocator = listData->ListData().Allocator.Value == AllocatorManager.Invalid.Value
? AllocatorManager.Persistent
: listData->ListData().Allocator
;
listData->Dispose();
AllocatorManager.Free(allocator, listData);
}
static public ClearToValueAllocator New <T>(byte ClearValue, ref T parent) where T : unmanaged, AllocatorManager.IAllocator
{
var temp = new ClearToValueAllocator();
temp.m_parent = parent.Handle;
temp.m_clearValue = ClearValue;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AllocatorManager.Register(ref temp);
parent.Handle.AddChildAllocator(temp.m_handle);
#endif
return(temp);
}
public void CustomAllocatorNativeListThrowsWhenAllocatorIsWrong()
{
AllocatorManager.Initialize();
var allocator0 = AllocatorManager.Persistent;
var allocator1 = AllocatorManager.TempJob;
var list = NativeList <byte> .New(100, ref allocator0);
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
list.Dispose(ref allocator1);
});
list.Dispose(ref allocator0);
AllocatorManager.Shutdown();
}
static void *CustomResize(void *oldPointer, long oldCount, long newCount, Allocator allocator, long size, int align)
{
AllocatorManager.Block block = default;
block.Range.Allocator = new AllocatorManager.AllocatorHandle {
Index = (ushort)allocator
};
block.Range.Items = (int)newCount;
block.Range.Pointer = (IntPtr)oldPointer;
block.BytesPerItem = (int)size;
block.Alignment = align;
block.AllocatedItems = (int)oldCount;
var error = AllocatorManager.Try(ref block);
CheckFailedToAllocate(error);
return((void *)block.Range.Pointer);
}
public void ReleasingChildHandlesWorks()
{
AllocatorManager.Initialize();
var origin = AllocatorManager.Persistent;
var storage = origin.AllocateBlock(default(byte), 100000); // allocate a block of bytes from Malloc.Persistent
var allocator = new AllocatorManager.StackAllocator(storage);
var list = NativeList <int> .New(10, ref allocator);
list.Add(0); // put something in the list, so it'll have a size for later
allocator.Dispose(); // ok to tear down the storage that the stack allocator used, too.
Assert.Throws <ObjectDisposedException>(
() => {
list[0] = 0; // we haven't disposed this list, but it was released automatically already. so this is an error.
});
storage.Dispose();
AllocatorManager.Shutdown();
}
public async Task <Sequence> GetNext(String key)
{
if (String.IsNullOrEmpty(key))
{
throw new HttpRequestException("The key should not be NULL!");
}
else
{
using (var dbFactory = new DbContextFactory(this._env.EnvironmentName))
using (var allocatorMng = new AllocatorManager(dbFactory))
{
var seq = allocatorMng.GetNextVal(key, this.getValProvider);
base._logger.Trace($"{key} Get {seq.Value}");
return(seq);
}
}
}
public void AllocatesAndFreesFromMono()
{
AllocatorManager.Initialize();
const int kLength = 100;
for (int i = 0; i < kLength; ++i)
{
using (var block = AllocatorManager.Persistent.Allocate <int>(Items: i))
{
Assert.AreNotEqual(IntPtr.Zero, block.Range.Pointer);
Assert.AreEqual(i, block.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block.Alignment);
Assert.AreEqual(AllocatorManager.Persistent.Value, block.Range.Allocator.Value);
}
}
AllocatorManager.Shutdown();
}
public async Task <HttpResponseMessage> Create([FromBody] HiLo hilo)
{
if (hilo == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
else
{
using (var dbFactory = new DbContextFactory(this._env.EnvironmentName))
using (var allocatorMng = new AllocatorManager(dbFactory))
{
bool isKeyExist = false;
allocatorMng.CreateHiLoInstance(hilo, out isKeyExist);
}
// this.CreateHiLo(hilo);
return(new HttpResponseMessage(HttpStatusCode.Created));
}
}
public unsafe int Try(ref AllocatorManager.Block block)
{
var temp = block.Range.Allocator;
block.Range.Allocator = m_parent;
var error = AllocatorManager.Try(ref block);
block.Range.Allocator = temp;
if (error != 0)
{
return(error);
}
if (block.Range.Pointer != IntPtr.Zero) // if we allocated or reallocated...
{
UnsafeUtility.MemSet((void *)block.Range.Pointer, m_clearValue, block.Bytes); // clear to a value.
}
return(0);
}
public void AllocatorVersioningWorks()
{
AllocatorManager.Initialize();
var origin = AllocatorManager.Persistent;
var storage = origin.AllocateBlock(default(byte), 100000); // allocate a block of bytes from Malloc.Persistent
for (var i = 1; i <= 3; ++i)
{
var allocator = new AllocatorManager.StackAllocator(storage);
var oldIndex = allocator.Handle.Index;
var oldVersion = allocator.Handle.Version;
allocator.Dispose();
var newVersion = AllocatorManager.SharedStatics.Version.Ref.Data.ElementAt(oldIndex);
Assert.AreEqual(oldVersion + 1, newVersion);
}
storage.Dispose();
AllocatorManager.Shutdown();
}
public void AllocatesAndFreesFromBurst()
{
AllocatorManager.Initialize();
const int kLength = 100;
using (var blocks = new NativeArray <AllocatorManager.Block>(kLength, Allocator.Persistent))
{
var allocateJob = new AllocateJob();
allocateJob.m_blocks = blocks;
allocateJob.Schedule(kLength, 1).Complete();
for (int i = 0; i < kLength; ++i)
{
var block = allocateJob.m_blocks[i];
if (i != 0)
{
Assert.AreNotEqual(IntPtr.Zero, block.Range.Pointer);
}
Assert.AreEqual(i, block.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block.Alignment);
Assert.AreEqual(AllocatorManager.Persistent.Value, block.Range.Allocator.Value);
}
var freeJob = new FreeJob();
freeJob.m_blocks = blocks;
freeJob.Schedule(kLength, 1).Complete();
for (int i = 0; i < kLength; ++i)
{
var block = allocateJob.m_blocks[i];
Assert.AreEqual(IntPtr.Zero, block.Range.Pointer);
Assert.AreEqual(0, block.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block.Alignment);
Assert.AreEqual(AllocatorManager.Persistent.Value, block.Range.Allocator.Value);
}
}
AllocatorManager.Shutdown();
}
public void SlabAllocatorWorks()
{
var SlabSizeInBytes = 256;
var SlabSizeInInts = SlabSizeInBytes / sizeof(int);
var Slabs = 256;
AllocatorManager.Initialize();
var origin = AllocatorManager.Persistent;
var backingStorage = origin.AllocateBlock(default(byte), Slabs * SlabSizeInBytes); // allocate a block of bytes from Malloc.Persistent
var allocator = new AllocatorManager.SlabAllocator(backingStorage, SlabSizeInBytes, Slabs * SlabSizeInBytes);
var block0 = allocator.AllocateBlock(default(int), SlabSizeInInts);
Assert.AreNotEqual(IntPtr.Zero, block0.Range.Pointer);
Assert.AreEqual(SlabSizeInInts, block0.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block0.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block0.Alignment);
Assert.AreEqual(1, allocator.Occupied[0]);
var block1 = allocator.AllocateBlock(default(int), SlabSizeInInts - 1);
Assert.AreNotEqual(IntPtr.Zero, block1.Range.Pointer);
Assert.AreEqual(SlabSizeInInts - 1, block1.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block1.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block1.Alignment);
Assert.AreEqual(3, allocator.Occupied[0]);
allocator.FreeBlock(ref block0);
Assert.AreEqual(2, allocator.Occupied[0]);
allocator.FreeBlock(ref block1);
Assert.AreEqual(0, allocator.Occupied[0]);
Assert.Throws <ArgumentException>(() =>
{
allocator.AllocateBlock(default(int), 65);
});
allocator.Dispose();
backingStorage.Dispose();
AllocatorManager.Shutdown();
}
public void SlabAllocatorWorks()
{
var SlabSizeInBytes = 256;
var SlabSizeInInts = SlabSizeInBytes / sizeof(int);
var Slabs = 256;
var customhandle = new AllocatorManager.AllocatorHandle {
Value = AllocatorManager.FirstUserIndex
};
AllocatorManager.Initialize();
using (var storage = AllocatorManager.Persistent.Allocate <byte>(Items: Slabs *SlabSizeInBytes)) // allocate a block of bytes from Malloc.Persistent
using (var installation = new AllocatorManager.AllocatorInstallation <AllocatorManager.SlabAllocator>(customhandle)) // and make a slab allocator from it
{
installation.Allocator = new AllocatorManager.SlabAllocator(storage, SlabSizeInBytes, Slabs * SlabSizeInBytes);
var block0 = customhandle.Allocate <int>(Items: SlabSizeInInts);
Assert.AreNotEqual(IntPtr.Zero, block0.Range.Pointer);
Assert.AreEqual(SlabSizeInInts, block0.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block0.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block0.Alignment);
Assert.AreEqual(1, installation.Allocator.Occupied[0]);
var block1 = customhandle.Allocate <int>(Items: SlabSizeInInts - 1);
Assert.AreNotEqual(IntPtr.Zero, block1.Range.Pointer);
Assert.AreEqual(SlabSizeInInts - 1, block1.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block1.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block1.Alignment);
Assert.AreEqual(3, installation.Allocator.Occupied[0]);
block0.Dispose();
Assert.AreEqual(2, installation.Allocator.Occupied[0]);
block1.Dispose();
Assert.AreEqual(0, installation.Allocator.Occupied[0]);
Assert.Throws <ArgumentException>(() =>
{
customhandle.Allocate <int>(Items: 65);
});
}
AllocatorManager.Shutdown();
}
public void StackAllocatorWorks()
{
AllocatorManager.Initialize();
var origin = AllocatorManager.Persistent;
var backingStorage = origin.AllocateBlock(default(byte), 100000); // allocate a block of bytes from Malloc.Persistent
var allocator = new AllocatorManager.StackAllocator(backingStorage);
const int kLength = 100;
for (int i = 1; i < kLength; ++i)
{
var block = allocator.AllocateBlock(default(int), i);
Assert.AreNotEqual(IntPtr.Zero, block.Range.Pointer);
Assert.AreEqual(i, block.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block.Alignment);
allocator.FreeBlock(ref block);
}
allocator.Dispose();
backingStorage.Dispose();
AllocatorManager.Shutdown();
}
public void AllocatesAndFreesFromMono()
{
AllocatorManager.Initialize();
const int kLength = 100;
for (int i = 0; i < kLength; ++i)
{
var allocator = AllocatorManager.Persistent;
var block = allocator.AllocateBlock(default(int), i);
if (i != 0)
{
Assert.AreNotEqual(IntPtr.Zero, block.Range.Pointer);
}
Assert.AreEqual(i, block.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block.Alignment);
Assert.AreEqual(AllocatorManager.Persistent.Value, block.Range.Allocator.Value);
allocator.FreeBlock(ref block);
}
AllocatorManager.Shutdown();
}
public byte *Allocate(int bytesToAllocate, int alignment)
{
CheckAllocationToLarge(bytesToAllocate);
var nextByteOffsetAligned = (m_nextByteOffset + alignment - 1) & ~(alignment - 1);
var nextBlockSize = nextByteOffsetAligned + bytesToAllocate;
if (m_blocks.Length == 0 || nextBlockSize > ms_BlockSize)
{
CheckExceededBudget();
// Allocate a fresh block of memory
m_blocks.Add(AllocatorManager.Allocate(m_handle, sizeof(byte), ms_BlockAlignment, ms_BlockSize));
m_allocations.Add(0);
nextByteOffsetAligned = 0;
}
var blockIndex = m_blocks.Length - 1;
var pointer = (byte *)m_blocks[blockIndex] + nextByteOffsetAligned;
m_nextByteOffset = nextByteOffsetAligned + bytesToAllocate;
m_allocations.Ptr[blockIndex]++;
return(pointer);
}
public void Free(void *pointer)
{
if (pointer == null)
{
return;
}
var blocks = m_allocations.Length; // how many blocks have we allocated?
for (var i = blocks - 1; i >= 0; --i)
{
var block = (byte *)m_blocks[i]; // get a pointer to the block.
if (pointer >= block && pointer < block + ms_BlockSize) // is the pointer we want to free in this block?
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (m_allocations.Ptr[i] <= 0) // if that block has no allocations, we can't proceed
{
throw new ArgumentException($"Cannot free this pointer from BlockAllocator: no more allocations to free in its block.");
}
#endif
if (--m_allocations.Ptr[i] == 0) // if this was the last allocation in the block,
{
if (i == blocks - 1) // if it's the last block,
{
m_nextByteOffset = 0; // just forget that we allocated anything from it, but keep it for later allocations
}
else
{
AllocatorManager.Free(m_handle, (void *)m_blocks[i]); // delete the block
m_blocks.RemoveAtSwapBack(i); // and forget we ever saw it
m_allocations.RemoveAtSwapBack(i); // and your dog toto, too
}
}
return;
}
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
throw new ArgumentException($"Cannot free this pointer from BlockAllocator: can't be found in any block.");
#endif
}
public void CustomAllocatorUnsafeListWorks()
{
AllocatorManager.Initialize();
var parent = AllocatorManager.Persistent;
var allocator = ClearToValueAllocator.New(0xFE, ref parent);
allocator.Register();
for (byte ClearValue = 0; ClearValue < 0xF; ++ClearValue)
{
allocator.m_clearValue = ClearValue;
var unsafelist = new UnsafeList <byte>(1, allocator.Handle);
const int kLength = 100;
unsafelist.Resize(kLength);
for (int i = 0; i < kLength; ++i)
{
Assert.AreEqual(ClearValue, unsafelist[i]);
}
unsafelist.Dispose();
}
allocator.Dispose();
AllocatorManager.Shutdown();
}
public unsafe void ReleasingChildAllocatorsWorks()
{
AllocatorManager.Initialize();
var origin = AllocatorManager.Persistent;
var parentStorage = origin.AllocateBlock(default(byte), 100000); // allocate a block of bytes from Malloc.Persistent
var parent = new AllocatorManager.StackAllocator(parentStorage); // and make a stack allocator from it
var childStorage = parent.AllocateBlock(default(byte), 10000); // allocate some space from the parent
var child = new AllocatorManager.StackAllocator(childStorage); // and make a stack allocator from it
parent.Dispose(); // tear down the parent allocator
Assert.Throws <ArgumentException>(() =>
{
child.Allocate(default(byte), 1000); // try to allocate from the child - it should fail.
});
parentStorage.Dispose();
AllocatorManager.Shutdown();
}
public void UserDefinedAllocatorWorks()
{
AllocatorManager.Initialize();
var parent = AllocatorManager.Persistent;
var allocator = ClearToValueAllocator.New(0, ref parent);
for (byte ClearValue = 0; ClearValue < 0xF; ++ClearValue)
{
allocator.m_clearValue = ClearValue;
const int kLength = 100;
for (int i = 1; i < kLength; ++i)
{
var block = allocator.AllocateBlock(default(int), i);
Assert.AreNotEqual(IntPtr.Zero, block.Range.Pointer);
Assert.AreEqual(i, block.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block.Alignment);
allocator.FreeBlock(ref block);
}
}
allocator.Dispose();
AllocatorManager.Shutdown();
}
public void StackAllocatorWorks()
{
var customhandle = new AllocatorManager.AllocatorHandle {
Value = AllocatorManager.FirstUserIndex
};
AllocatorManager.Initialize();
using (var storage = AllocatorManager.Persistent.Allocate <byte>(100000)) // allocate a block of bytes from Malloc.Persistent
using (var installation = new AllocatorManager.AllocatorInstallation <AllocatorManager.StackAllocator>(customhandle)) // and make a stack allocator from it
{
installation.Allocator.m_storage = storage; // install the block into the allocator
const int kLength = 100;
for (int i = 1; i < kLength; ++i)
{
var block = customhandle.Allocate <int>(Items: i);
Assert.AreNotEqual(IntPtr.Zero, block.Range.Pointer);
Assert.AreEqual(i, block.Range.Items);
Assert.AreEqual(UnsafeUtility.SizeOf <int>(), block.BytesPerItem);
Assert.AreEqual(UnsafeUtility.AlignOf <int>(), block.Alignment);
}
}
AllocatorManager.Shutdown();
}
public static UnsafeNodesList *Create(int length, Allocator allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory)
{
var handle = new AllocatorManager.AllocatorHandle {
Value = (int)allocator
};
UnsafeNodesList *listData = AllocatorManager.Allocate <UnsafeNodesList>(handle);
UnsafeUtility.MemClear(listData, UnsafeUtility.SizeOf <UnsafeNodesList>());
listData->allocator = allocator;
listData->emptyIndices = UnsafeList.Create(UnsafeUtility.SizeOf <int>(), UnsafeUtility.AlignOf <int>(), length, allocator);
if (length != 0)
{
listData->Resize(length);
}
if (options == NativeArrayOptions.ClearMemory && listData->ptr != null)
{
UnsafeUtility.MemClear(listData->ptr, listData->length * UnsafeUtility.SizeOf <int>());
}
return(listData);
}
