#if ENABLE_UNITY_COLLECTIONS_CHECKS
#define ENABLE_UNITY_ALLOCATION_CHECKS
#endif
#pragma warning disable 0649

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using AOT;
using Unity.Burst;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine.Assertions;
using Unity.Jobs.LowLevel.Unsafe;

namespace Unity.Collections
{
    /// <summary>
    /// Manages custom memory allocators.
    /// </summary>
    public static class AllocatorManager
    {
        internal static Block AllocateBlock<T>(ref this T t, int sizeOf, int alignOf, int items) where T : unmanaged, IAllocator
        {
            CheckValid(t.Handle);
            Block block = default;
            block.Range.Pointer = IntPtr.Zero;
            block.Range.Items = items;
            block.Range.Allocator = t.Handle;
            block.BytesPerItem = sizeOf;
            // Make the alignment multiple of cacheline size
            block.Alignment = math.max(JobsUtility.CacheLineSize, alignOf);

            var error = t.Try(ref block);
            CheckFailedToAllocate(error);
            return block;
        }

        internal static Block AllocateBlock<T,U>(ref this T t, U u, int items) where T : unmanaged, IAllocator where U : unmanaged
        {
            return AllocateBlock(ref t, UnsafeUtility.SizeOf<U>(), UnsafeUtility.AlignOf<U>(), items);
        }

        internal static unsafe void* Allocate<T>(ref this T t, int sizeOf, int alignOf, int items) where T : unmanaged, IAllocator
        {
            return (void*)AllocateBlock(ref t, sizeOf, alignOf, items).Range.Pointer;
        }

        internal static unsafe U* Allocate<T,U>(ref this T t, U u, int items) where T : unmanaged, IAllocator where U : unmanaged
        {
            return (U*)Allocate(ref t, UnsafeUtility.SizeOf<U>(), UnsafeUtility.AlignOf<U>(), items);
        }

        internal static unsafe void* AllocateStruct<T, U>(ref this T t, U u, int items) where T : unmanaged, IAllocator where U : struct
        {
            return (void*)Allocate(ref t, UnsafeUtility.SizeOf<U>(), UnsafeUtility.AlignOf<U>(), items);
        }

        internal static unsafe void FreeBlock<T>(ref this T t, ref Block block) where T : unmanaged, IAllocator
        {
            CheckValid(t.Handle);
            block.Range.Items = 0;
            var error = t.Try(ref block);
            CheckFailedToFree(error);
        }

        internal static unsafe void Free<T>(ref this T t, void* pointer, int sizeOf, int alignOf, int items) where T : unmanaged, IAllocator
        {
            if (pointer == null)
                return;
            Block block = default;
            block.AllocatedItems = items;
            block.Range.Pointer = (IntPtr)pointer;
            block.BytesPerItem = sizeOf;
            block.Alignment = alignOf;
            t.FreeBlock(ref block);
        }

        internal static unsafe void Free<T,U>(ref this T t, U* pointer, int items) where T : unmanaged, IAllocator where U : unmanaged
        {
            Free(ref t, pointer, UnsafeUtility.SizeOf<U>(), UnsafeUtility.AlignOf<U>(), items);
        }

        /// <summary>
        /// Allocates memory from an allocator.
        /// </summary>
        /// <param name="handle">A handle to the allocator.</param>
        /// <param name="itemSizeInBytes">The number of bytes to allocate.</param>
        /// <param name="alignmentInBytes">The alignment in bytes (must be a power of two).</param>
        /// <param name="items">The number of values to allocate space for. Defaults to 1.</param>
        /// <returns>A pointer to the allocated memory.</returns>
        public unsafe static void* Allocate(AllocatorHandle handle, int itemSizeInBytes, int alignmentInBytes, int items = 1)
        {
            return handle.Allocate(itemSizeInBytes, alignmentInBytes, items);
        }

        /// <summary>
        /// Allocates enough memory for an unmanaged value of a given type.
        /// </summary>
        /// <typeparam name="T">The type of value to allocate for.</typeparam>
        /// <param name="handle">A handle to the allocator.</param>
        /// <param name="items">The number of values to allocate for space for. Defaults to 1.</param>
        /// <returns>A pointer to the allocated memory.</returns>
        public unsafe static T* Allocate<T>(AllocatorHandle handle, int items = 1) where T : unmanaged
        {
            return handle.Allocate(default(T), items);
        }

        /// <summary>
        /// Frees an allocation.
        /// </summary>
        /// <remarks>For some allocators, the size of the allocation must be known to properly deallocate.
        /// Other allocators only need the pointer when deallocating and so will ignore `itemSizeInBytes`, `alignmentInBytes` and `items`.</remarks>
        /// <param name="handle">A handle to the allocator.</param>
        /// <param name="pointer">A pointer to the allocated memory.</param>
        /// <param name="itemSizeInBytes">The size in bytes of the allocation.</param>
        /// <param name="alignmentInBytes">The alignment in bytes (must be a power of two).</param>
        /// <param name="items">The number of values that the memory was allocated for.</param>
        public unsafe static void Free(AllocatorHandle handle, void* pointer, int itemSizeInBytes, int alignmentInBytes, int items = 1)
        {
            handle.Free(pointer, itemSizeInBytes, alignmentInBytes, items);
        }

        /// <summary>
        /// Frees an allocation.
        /// </summary>
        /// <param name="handle">A handle to the allocator.</param>
        /// <param name="pointer">A pointer to the allocated memory.</param>
        public unsafe static void Free(AllocatorHandle handle, void* pointer)
        {
            handle.Free((byte*)pointer, 1);
        }

        /// <summary>
        /// Frees an allocation.
        /// </summary>
        /// <remarks>For some allocators, the size of the allocation must be known to properly deallocate.
        /// Other allocators only need the pointer when deallocating and so  will ignore `T` and `items`.</remarks>
        /// <typeparam name="T">The type of value that the memory was allocated for.</typeparam>
        /// <param name="handle">A handle to the allocator.</param>
        /// <param name="pointer">A pointer to the allocated memory.</param>
        /// <param name="items">The number of values that the memory was allocated for.</param>
        public unsafe static void Free<T>(AllocatorHandle handle, T* pointer, int items = 1) where T : unmanaged
        {
            handle.Free(pointer, items);
        }

        /// <summary>
        /// Corresponds to Allocator.Invalid.
        /// </summary>
        /// <value>Corresponds to Allocator.Invalid.</value>
        public static readonly AllocatorHandle Invalid = new AllocatorHandle { Index = 0 };

        /// <summary>
        /// Corresponds to Allocator.None.
        /// </summary>
        /// <value>Corresponds to Allocator.None.</value>
        public static readonly AllocatorHandle None = new AllocatorHandle { Index = 1 };

        /// <summary>
        /// Corresponds to Allocator.Temp.
        /// </summary>
        /// <value>Corresponds to Allocator.Temp.</value>
        public static readonly AllocatorHandle Temp = new AllocatorHandle { Index = 2 };

        /// <summary>
        /// Corresponds to Allocator.TempJob.
        /// </summary>
        /// <value>Corresponds to Allocator.TempJob.</value>
        public static readonly AllocatorHandle TempJob = new AllocatorHandle { Index = 3 };

        /// <summary>
        /// Corresponds to Allocator.Persistent.
        /// </summary>
        /// <value>Corresponds to Allocator.Persistent.</value>
        public static readonly AllocatorHandle Persistent = new AllocatorHandle { Index = 4 };

        /// <summary>
        /// Corresponds to Allocator.AudioKernel.
        /// </summary>
        /// <value>Corresponds to Allocator.AudioKernel.</value>
        public static readonly AllocatorHandle AudioKernel = new AllocatorHandle { Index = 5 };

        /// <summary>
        /// Used for calling an allocator function.
        /// </summary>
        public delegate int TryFunction(IntPtr allocatorState, ref Block block);

        /// <summary>
        /// Represents the allocator function used within an allocator.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        public struct AllocatorHandle : IAllocator
        {
            internal ref TableEntry TableEntry => ref SharedStatics.TableEntry.Ref.Data.ElementAt(Index);
            internal bool IsInstalled => ((SharedStatics.IsInstalled.Ref.Data.ElementAt(Index>>6) >> (Index&63)) & 1) != 0;

            internal void IncrementVersion()
            {
#if ENABLE_UNITY_ALLOCATION_CHECKS
                if (IsInstalled && IsCurrent)
                {
                    // When allocator version is larger than 0x7FFF, allocator.ToAllocator
                    // returns a negative value which causes problem when comparing to Allocator.None.
                    // So only lower 15 bits of version is valid.
                    Version = OfficialVersion = (ushort)(++OfficialVersion & 0x7FFF);
                }
#endif
            }

            internal void Rewind()
            {
#if ENABLE_UNITY_ALLOCATION_CHECKS
                InvalidateDependents();
                IncrementVersion();
#endif
            }

            internal void Install(TableEntry tableEntry)
            {
#if ENABLE_UNITY_ALLOCATION_CHECKS
                // if this allocator has never been visited before, then the unsafelists for its child allocators
                // and child safety handles are uninitialized, which means their allocator is Allocator.Invalid.
                // rectify that here.
                if(ChildSafetyHandles.Allocator.Value != (int)Allocator.Persistent)
                {
                    ChildSafetyHandles = new UnsafeList<AtomicSafetyHandle>(0, Allocator.Persistent);
                    ChildAllocators = new UnsafeList<AllocatorHandle>(0, Allocator.Persistent);
                }
#endif
                Rewind();
                TableEntry = tableEntry;
            }

#if ENABLE_UNITY_ALLOCATION_CHECKS
            internal ref ushort OfficialVersion => ref SharedStatics.Version.Ref.Data.ElementAt(Index);
            internal ref UnsafeList<AtomicSafetyHandle> ChildSafetyHandles => ref SharedStatics.ChildSafetyHandles.Ref.Data.ElementAt(Index);
            internal ref UnsafeList<AllocatorHandle> ChildAllocators => ref SharedStatics.ChildAllocators.Ref.Data.ElementAt(Index);
            internal ref AllocatorHandle Parent => ref SharedStatics.Parent.Ref.Data.ElementAt(Index);
            internal ref int IndexInParent => ref SharedStatics.IndexInParent.Ref.Data.ElementAt(Index);

            internal bool IsCurrent => (Version == 0) || (Version == OfficialVersion);
            internal bool IsValid => (Index < FirstUserIndex) || (IsInstalled && IsCurrent);

            /// <summary>
            ///   <para>Determines if the handle is still valid, because we intend to release it if it is.</para>
            /// </summary>
            /// <param name="handle">Safety handle.</param>
            internal static unsafe bool CheckExists(AtomicSafetyHandle handle)
            {
                bool res = false;
#if UNITY_DOTSRUNTIME
                // In DOTS Runtime, AtomicSaftyHandle version is at 8 bytes offset of nodePtr
                int* versionNode = (int*)((byte *)handle.nodePtr + sizeof(void *));
                res = (handle.version == (*versionNode & AtomicSafetyNodeVersionMask.ReadWriteDisposeUnprotect));
#else
                int* versionNode = (int*) (void*) handle.versionNode;
                res = (handle.version == (*versionNode & AtomicSafetyHandle.ReadWriteDisposeCheck));
#endif
                return res;
            }

            internal static unsafe bool AreTheSame(AtomicSafetyHandle a, AtomicSafetyHandle b)
            {
                if(a.version != b.version)
                    return false;
#if UNITY_DOTSRUNTIME
                if(a.nodePtr != b.nodePtr)
#else
                if(a.versionNode != b.versionNode)
#endif
                    return false;
                return true;
            }

            internal static bool AreTheSame(AllocatorHandle a, AllocatorHandle b)
            {
                if(a.Index != b.Index)
                    return false;
                if(a.Version != b.Version)
                    return false;
                return true;
            }

            internal bool NeedsUseAfterFreeTracking()
            {
                if(IsValid == false)
                    return false;
                if(ChildSafetyHandles.Allocator.Value != (int)Allocator.Persistent)
                    return false;
                return true;
            }

            /// <summary>
            /// For internal use only.
            /// </summary>
            /// <value>For internal use only.</value>
            public const int InvalidChildSafetyHandleIndex = -1;

            internal int AddSafetyHandle(AtomicSafetyHandle handle)
            {
                if(!NeedsUseAfterFreeTracking())
                    return InvalidChildSafetyHandleIndex;
                var result = ChildSafetyHandles.Length;
                ChildSafetyHandles.Add(handle);
                return result;
            }

            internal bool TryRemoveSafetyHandle(AtomicSafetyHandle handle, int safetyHandleIndex)
            {
                if(!NeedsUseAfterFreeTracking())
                    return false;
                if(safetyHandleIndex == InvalidChildSafetyHandleIndex)
                    return false;
                safetyHandleIndex = math.min(safetyHandleIndex, ChildSafetyHandles.Length - 1);
                while(safetyHandleIndex >= 0)
                {
                    unsafe
                    {
                        var safetyHandle = ChildSafetyHandles.Ptr + safetyHandleIndex;
                        if(AreTheSame(*safetyHandle, handle))
                        {
                            ChildSafetyHandles.RemoveAtSwapBack(safetyHandleIndex);
                            return true;
                        }
                    }
                    --safetyHandleIndex;
                }
                return false;
            }

            /// <summary>
            /// For internal use only.
            /// </summary>
            /// <value>For internal use only.</value>
            public const int InvalidChildAllocatorIndex = -1;

            internal int AddChildAllocator(AllocatorHandle handle)
            {
                if(!NeedsUseAfterFreeTracking())
                    return InvalidChildAllocatorIndex;
                var result = ChildAllocators.Length;
                ChildAllocators.Add(handle);
                handle.Parent = this;
                handle.IndexInParent = result;
                return result;
            }

            internal bool TryRemoveChildAllocator(AllocatorHandle handle, int childAllocatorIndex)
            {
                if(!NeedsUseAfterFreeTracking())
                    return false;
                if(childAllocatorIndex == InvalidChildAllocatorIndex)
                    return false;
                childAllocatorIndex = math.min(childAllocatorIndex, ChildAllocators.Length - 1);
                while(childAllocatorIndex >= 0)
                {
                    unsafe
                    {
                        var allocatorHandle = ChildAllocators.Ptr + childAllocatorIndex;
                        if(AreTheSame(*allocatorHandle, handle))
                        {
                            ChildAllocators.RemoveAtSwapBack(childAllocatorIndex);
                            return true;
                        }
                    }
                    --childAllocatorIndex;
                }
                return false;
            }

            // when you rewind an allocator, it invalidates and unregisters all of its child allocators - allocators that use as
            // backing memory, memory that was allocated from this (parent) allocator. the rewind operation was itself unmanaged,
            // until we added a managed global table of delegates alongside the unmanaged global table of function pointers. once
            // this table was added, the "unregister" extension function became managed, because it manipulates a managed array of
            // delegates.

            // a workaround (UnmanagedUnregister) was found that makes it possible for rewind to become unmanaged again: only in
            // the case that we rewind an allocator and invalidate all of its child allocators, we then unregister the child
            // allocators without touching the managed array of delegates as well.

            // this can "leak" delegates - it's possible for this to cause us to hold onto a GC reference to a delegate until
            // the end of the program, long after the delegate is no longer needed. but, there are only 65,536 such slots to
            // burn, and delegates are small data structures, and the leak ends when a delegate slot is reused, and most importantly,
            // when we've rewound an allocator while child allocators remain registered, we are likely before long to encounter
            // a use-before-free crash or a safety handle violation, both of which are likely to terminate the session before
            // anything can leak.

            [NotBurstCompatible]
            internal void InvalidateDependents()
            {
                if(!NeedsUseAfterFreeTracking())
                    return;
                for(var i = 0; i < ChildSafetyHandles.Length; ++i)
                {
                    unsafe
                    {
                        AtomicSafetyHandle* handle = ChildSafetyHandles.Ptr + i;
                        if(CheckExists(*handle))
                            AtomicSafetyHandle.Release(*handle);
                    }
                }
                ChildSafetyHandles.Clear();
                if(Parent.IsValid)
                    Parent.TryRemoveChildAllocator(this, IndexInParent);
                Parent = default;
                IndexInParent = InvalidChildAllocatorIndex;
                for(var i = 0; i < ChildAllocators.Length; ++i)
                {
                    unsafe
                    {
                        AllocatorHandle* handle = (AllocatorHandle*)ChildAllocators.Ptr + i;
                        if(handle->IsValid)
                            handle->UnmanagedUnregister(); // see above comment
                    }
                }
                ChildAllocators.Clear();
            }

#endif

            /// <summary>
            /// Returns the AllocatorHandle of an allocator.
            /// </summary>
            /// <param name="a">The Allocator to copy.</param>
            /// <returns>The AllocatorHandle of an allocator.</returns>
            public static implicit operator AllocatorHandle(Allocator a) => new AllocatorHandle
            {
                Index = (ushort)((uint)a & 0xFFFF),
                Version = (ushort)((uint)a >> 16)
            };

            /// <summary>
            /// This allocator's index into the global table of allocator functions.
            /// </summary>
            /// <value>This allocator's index into the global table of allocator functions.</value>
            public ushort Index;

            /// <summary>
            /// This allocator's version number.
            /// </summary>
            /// <remarks>An allocator function is uniquely identified by its *combination* of <see cref="Index"/> and <see cref="Version"/> together: each
            /// index has a version number that starts at 0; the version number is incremented each time the allocator is invalidated.  Only the
            /// lower 15 bits of Version is in use because when allocator version is larger than 0x7FFF, allocator.ToAllocator returns a negative value
            /// which causes problem when comparing to Allocator.None.
            /// </remarks>
            /// <value>This allocator's version number.</value>
            public ushort Version;

            /// <summary>
            /// The <see cref="Index"/> cast to int.
            /// </summary>
            /// <value>The <see cref="Index"/> cast to int.</value>
            public int Value => Index;

            /// <summary>
            /// Allocates a block from this allocator.
            /// </summary>
            /// <typeparam name="T">The type of value to allocate for.</typeparam>
            /// <param name="block">Outputs the allocated block.</param>
            /// <param name="items">The number of values to allocate for.</param>
            /// <returns>0 if successful. Otherwise, returns the error code from the allocator function.</returns>
            public int TryAllocateBlock<T>(out Block block, int items) where T : struct
            {
                block = new Block
                {
                    Range = new Range { Items = items, Allocator = this },
                    BytesPerItem = UnsafeUtility.SizeOf<T>(),
                    Alignment = 1 << math.min(3, math.tzcnt(UnsafeUtility.SizeOf<T>()))
                };
                var returnCode = Try(ref block);
                return returnCode;
            }

            /// <summary>
            /// Allocates a block with this allocator function.
            /// </summary>
            /// <typeparam name="T">The type of value to allocate for.</typeparam>
            /// <param name="items">The number of values to allocate for.</param>
            /// <returns>The allocated block.</returns>
            /// <exception cref="ArgumentException">Thrown if the allocator is not valid or if the allocation failed.</exception>
            public Block AllocateBlock<T>(int items) where T : struct
            {
                CheckValid(this);
                var error = TryAllocateBlock<T>(out Block block, items);
                CheckAllocatedSuccessfully(error);
                return block;
            }

            [Conditional("ENABLE_UNITY_ALLOCATION_CHECKS")]
            static void CheckAllocatedSuccessfully(int error)
            {
                if (error != 0)
                    throw new ArgumentException($"Error {error}: Failed to Allocate");
            }

            /// <summary>
            /// For internal use only.
            /// </summary>
            /// <value>For internal use only.</value>
            public TryFunction Function => default;

            /// <summary>
            /// Tries to allocate the block with this allocator.
            /// </summary>
            /// <param name="block">The block to allocate.</param>
            /// <returns>0 if successful. Otherwise, returns an error code.</returns>
            public int Try(ref Block block)
            {
                block.Range.Allocator = this;
                var error = AllocatorManager.Try(ref block);
                return error;
            }

            /// <summary>
            /// This handle.
            /// </summary>
            /// <value>This handle.</value>
            public AllocatorHandle Handle { get { return this; } set { this = value; } }

            /// <summary>
            /// Retrieve the Allocator associated with this allocator handle.
            /// </summary>
            /// <value>The Allocator retrieved.</value>
            public Allocator ToAllocator
            {
                get
                {
                    uint lo = Index;
                    uint hi = Version;
                    uint value = (hi << 16) | lo;
                    return (Allocator)value;
                }
            }

            /// <summary>
            /// Check whether this allocator is a custom allocator.
            /// </summary>
            /// <remarks>The AllocatorHandle is a custom allocator if its Index is larger or equal to `FirstUserIndex`.</remarks>
            /// <value>True if this AllocatorHandle is a custom allocator.</value>
            public bool IsCustomAllocator { get { return this.Index >= FirstUserIndex; } }

            /// <summary>
            /// Dispose the allocator.
            /// </summary>
            public void Dispose()
            {
                Rewind();
            }
        }

        /// <summary>
        /// For internal use only.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        public struct BlockHandle
        {
            /// <summary>
            /// Represents the handle.
            /// </summary>
            /// <value>Represents the handle.</value>
            public ushort Value;
        }

        /// <summary>
        /// A range of allocated memory.
        /// </summary>
        /// <remarks>The name is perhaps misleading: only in combination with a <see cref="Block"/> does
        /// a `Range` have sufficient information to represent the number of bytes in an allocation. The reason `Range` is its own type that's separate from `Block`
        /// stems from some efficiency concerns in the implementation details. In most cases, a `Range` is only used in conjunction with an associated `Block`.
        /// </remarks>
        [StructLayout(LayoutKind.Sequential)]
        public struct Range : IDisposable
        {
            /// <summary>
            /// Pointer to the start of this range.
            /// </summary>
            /// <value>Pointer to the start of this range.</value>
            public IntPtr Pointer; //  0

            /// <summary>
            /// Number of items allocated in this range.
            /// </summary>
            /// <remarks>The actual allocation may be larger. See <see cref="Block.AllocatedItems"/>.</remarks>
            /// <value>Number of items allocated in this range. </value>
            public int Items; //  8

            /// <summary>
            /// The allocator function used for this range.
            /// </summary>
            /// <value>The allocator function used for this range.</value>
            public AllocatorHandle Allocator; // 12

            /// <summary>
            /// Deallocates the memory represented by this range.
            /// </summary>
            /// <remarks>
            /// Same as disposing the <see cref="Block"/> which contains this range.
            ///
            /// Cannot be used with allocators which need the allocation size to deallocate.
            /// </remarks>
            public void Dispose()
            {
                Block block = new Block { Range = this };
                block.Dispose();
                this = block.Range;
            }
        }

        /// <summary>
        /// Represents an individual allocation within an allocator.
        /// </summary>
        /// <remarks>A block consists of a <see cref="Range"/> plus metadata about the type of elements for which the block was allocated.</remarks>
        [StructLayout(LayoutKind.Sequential)]
        public struct Block : IDisposable
        {
            /// <summary>
            /// The range of memory encompassed by this block.
            /// </summary>
            /// <value>The range of memory encompassed by this block.</value>
            public Range Range;

            /// <summary>
            /// Number of bytes per item.
            /// </summary>
            /// <value>Number of bytes per item.</value>
            public int BytesPerItem;

            /// <summary>
            /// Number of items allocated for.
            /// </summary>
            /// <value>Number of items allocated for.</value>
            public int AllocatedItems;

            /// <summary>
            /// Log2 of the byte alignment.
            /// </summary>
            /// <remarks>The alignment must always be power of 2. Storing the alignment as its log2 helps enforces this.</remarks>
            /// <value>Log2 of the byte alignment.</value>
            public byte Log2Alignment;

            /// <summary>
            /// This field only exists to pad the `Block` struct. Ignore it.
            /// </summary>
            /// <value>This field only exists to pad the `Block` struct. Ignore it.</value>
            public byte Padding0;

            /// <summary>
            /// This field only exists to pad the `Block` struct. Ignore it.
            /// </summary>
            /// <value>This field only exists to pad the `Block` struct. Ignore it.</value>
            public ushort Padding1;

            /// <summary>
            /// This field only exists to pad the `Block` struct. Ignore it.
            /// </summary>
            /// <value>This field only exists to pad the `Block` struct. Ignore it.</value>
            public uint Padding2;

            /// <summary>
            /// Number of bytes requested for this block.
            /// </summary>
            /// <remarks>The actual allocation size may be larger due to alignment.</remarks>
            /// <value>Number of bytes requested for this block.</value>
            public long Bytes => BytesPerItem * Range.Items;

            /// <summary>
            /// Number of bytes allocated for this block.
            /// </summary>
            /// <remarks>The requested allocation size may be smaller. Any excess is due to alignment</remarks>
            /// <value>Number of bytes allocated for this block.</value>
            public long AllocatedBytes => BytesPerItem * AllocatedItems;

            /// <summary>
            /// The alignment.
            /// </summary>
            /// <remarks>Must be power of 2 that's greater than or equal to 0.
            ///
            /// Set alignment *before* the allocation is made. Setting it after has no effect on the allocation.</remarks>
            /// <param name="value">A new alignment. If not a power of 2, it will be rounded up to the next largest power of 2.</param>
            /// <value>The alignment.</value>
            public int Alignment
            {
                get => 1 << Log2Alignment;
                set => Log2Alignment = (byte)(32 - math.lzcnt(math.max(1, value) - 1));
            }

            /// <summary>
            /// Deallocates this block.
            /// </summary>
            /// <remarks>Same as <see cref="TryAllocate"/>.</remarks>
            public void Dispose()
            {
                TryFree();
            }

            /// <summary>
            /// Attempts to allocate this block.
            /// </summary>
            /// <returns>0 if successful. Otherwise, returns the error code from the allocator function.</returns>
            public int TryAllocate()
            {
                Range.Pointer = IntPtr.Zero;
                return Try(ref this);
            }

            /// <summary>
            /// Attempts to free this block.
            /// </summary>
            /// <returns>0 if successful. Otherwise, returns the error code from the allocator function.</returns>
            public int TryFree()
            {
                Range.Items = 0;
                return Try(ref this);
            }

            /// <summary>
            /// Allocates this block.
            /// </summary>
            /// <exception cref="ArgumentException">Thrown if safety checks are enabled and the allocation fails.</exception>
            public void Allocate()
            {
                var error = TryAllocate();
                CheckFailedToAllocate(error);
            }

            /// <summary>
            /// Frees the block.
            /// </summary>
            /// <exception cref="ArgumentException">Thrown if safety checks are enabled and the deallocation fails.</exception>
            public void Free()
            {
                var error = TryFree();
                CheckFailedToFree(error);
            }

            [Conditional("ENABLE_UNITY_ALLOCATION_CHECKS")]
            void CheckFailedToAllocate(int error)
            {
                if (error != 0)
                    throw new ArgumentException($"Error {error}: Failed to Allocate {this}");
            }

            [Conditional("ENABLE_UNITY_ALLOCATION_CHECKS")]
            void CheckFailedToFree(int error)
            {
                if (error != 0)
                    throw new ArgumentException($"Error {error}: Failed to Free {this}");
            }
        }

        /// <summary>
        /// An allocator function pointer.
        /// </summary>
        public interface IAllocator : IDisposable
        {
            /// <summary>
            /// The allocator function. It can allocate, deallocate, or reallocate.
            /// </summary>
            TryFunction Function { get; }

            /// <summary>
            /// Invoke the allocator function.
            /// </summary>
            /// <param name="block">The block to allocate, deallocate, or reallocate. See <see cref="AllocatorManager.Try"/></param>
            /// <returns>0 if successful. Otherwise, returns the error code from the allocator function.</returns>
            int Try(ref Block block);

            /// <summary>
            /// This allocator.
            /// </summary>
            /// <value>This allocator.</value>
            AllocatorHandle Handle { get; set; }

            /// <summary>
            /// Cast the Allocator index into Allocator
            /// </summary>
            Allocator ToAllocator { get; }

            /// <summary>
            /// Check whether an allocator is a custom allocator
            /// </summary>
            bool IsCustomAllocator { get; }
        }


        /// <summary>
        /// Memory allocation Success status
        /// </summary>
        public const int kErrorNone = 0;

        /// <summary>
        /// Memory allocation Buffer Overflow status
        /// </summary>
        public const int kErrorBufferOverflow = -1;

#if !UNITY_IOS

        [BurstDiscard]
        private static void CheckDelegate(ref bool useDelegate)
        {
            //@TODO: This should use BurstCompiler.IsEnabled once that is available as an efficient API.
            useDelegate = true;
        }

        private static bool UseDelegate()
        {
            bool result = false;
            CheckDelegate(ref result);
            return result;
        }
#endif

        private static int allocate_block(ref Block block)
        {
            TableEntry tableEntry = default;
            tableEntry = block.Range.Allocator.TableEntry;
            var function = new FunctionPointer<TryFunction>(tableEntry.function);
            // this is a path for bursted caller, for non-Burst C#, it generates garbage each time we call Invoke
            return function.Invoke(tableEntry.state, ref block);
        }

#if !UNITY_IOS
        [BurstDiscard]
        private static void forward_mono_allocate_block(ref Block block, ref int error)
        {
            TableEntry tableEntry = default;
            tableEntry = block.Range.Allocator.TableEntry;

            var index = block.Range.Allocator.Handle.Index;
            if (index >= Managed.kMaxNumCustomAllocator)
            {
                throw new ArgumentException("Allocator index into TryFunction delegate table exceeds maximum.");
            }
            ref TryFunction function = ref Managed.TryFunctionDelegates[block.Range.Allocator.Handle.Index];
            error = function(tableEntry.state, ref block);
        }
#endif

        internal static Allocator LegacyOf(AllocatorHandle handle)
        {
            if (handle.Value >= FirstUserIndex)
                return Allocator.Persistent;
            return (Allocator) handle.Value;
        }

        static unsafe int TryLegacy(ref Block block)
        {
            if (block.Range.Pointer == IntPtr.Zero) // Allocate
            {
                block.Range.Pointer = (IntPtr)Memory.Unmanaged.Allocate(block.Bytes, block.Alignment, LegacyOf(block.Range.Allocator));
                block.AllocatedItems = block.Range.Items;
                return (block.Range.Pointer == IntPtr.Zero) ? -1 : 0;
            }
            if (block.Bytes == 0) // Free
            {
                if (LegacyOf(block.Range.Allocator) != Allocator.None)
                {
                    Memory.Unmanaged.Free((void*)block.Range.Pointer, LegacyOf(block.Range.Allocator));
                }
                block.Range.Pointer = IntPtr.Zero;
                block.AllocatedItems = 0;
                return 0;
            }
            // Reallocate (keep existing pointer and change size if possible. otherwise, allocate new thing and copy)
            return -1;
        }

        /// <summary>
        /// Invokes the allocator function of a block.
        /// </summary>
        /// <remarks>The allocator function is looked up from a global table.
        ///
        /// - If the block range's Pointer is null, it will allocate.
        /// - If the block range's Pointer is not null, it will reallocate.
        /// - If the block range's Items is 0, it will deallocate.
        /// </remarks>
        /// <param name="block">The block to allocate, deallocate, or reallocate.</param>
        /// <returns>0 if successful. Otherwise, returns the error code from the block's allocator function.</returns>
        public static unsafe int Try(ref Block block)
        {
            if (block.Range.Allocator.Value < FirstUserIndex)
                return TryLegacy(ref block);
            TableEntry tableEntry = default;
            tableEntry = block.Range.Allocator.TableEntry;
            var function = new FunctionPointer<TryFunction>(tableEntry.function);
#if ENABLE_UNITY_ALLOCATION_CHECKS
            // if the allocator being passed in has a version of 0, that means "whatever the current version is."
            // so we patch it here, with whatever the current version is...
            if(block.Range.Allocator.Version == 0)
                block.Range.Allocator.Version = block.Range.Allocator.OfficialVersion;
#endif

#if !UNITY_IOS
            if (UseDelegate())
            {
                int error = kErrorNone;
                forward_mono_allocate_block(ref block, ref error);
                return error;
            }
#endif
            return allocate_block(ref block);
        }

        /// <summary>
        /// A stack allocator with no storage of its own. Uses the storage of its parent.
        /// </summary>
        [BurstCompile(CompileSynchronously = true)]
        internal struct StackAllocator : IAllocator, IDisposable
        {
            public AllocatorHandle Handle { get { return m_handle; } set { m_handle = value; } }
            public Allocator ToAllocator { get { return m_handle.ToAllocator; } }
            public bool IsCustomAllocator { get { return m_handle.IsCustomAllocator; } }

            internal AllocatorHandle m_handle;

            internal Block m_storage;
            internal long m_top;

            public void Initialize(Block storage)
            {
                m_storage = storage;
                m_top = 0;
#if ENABLE_UNITY_ALLOCATION_CHECKS
                m_storage.Range.Allocator.AddChildAllocator(Handle);
#endif
            }

            public unsafe int Try(ref Block block)
            {
                if (block.Range.Pointer == IntPtr.Zero) // Allocate
                {
                    if (m_top + block.Bytes > m_storage.Bytes)
                    {
                        return -1;
                    }

                    block.Range.Pointer = (IntPtr)((byte*)m_storage.Range.Pointer + m_top);
                    block.AllocatedItems = block.Range.Items;
                    m_top += block.Bytes;
                    return 0;
                }

                if (block.Bytes == 0) // Free
                {
                    if ((byte*)block.Range.Pointer - (byte*)m_storage.Range.Pointer == (long)(m_top - block.AllocatedBytes))
                    {
                        m_top -= block.AllocatedBytes;
                        var blockSizeInBytes = block.AllocatedItems * block.BytesPerItem;
                        block.Range.Pointer = IntPtr.Zero;
                        block.AllocatedItems = 0;
                        return 0;
                    }

                    return -1;
                }

                // Reallocate (keep existing pointer and change size if possible. otherwise, allocate new thing and copy)
                return -1;
            }

            [BurstCompile(CompileSynchronously = true)]
			[MonoPInvokeCallback(typeof(TryFunction))]
            public static unsafe int Try(IntPtr allocatorState, ref Block block)
            {
                return ((StackAllocator*)allocatorState)->Try(ref block);
            }

            public TryFunction Function => Try;

            public void Dispose()
            {
                m_handle.Rewind();
            }
        }

        /// <summary>
        /// Slab allocator with no backing storage.
        /// </summary>
        [BurstCompile(CompileSynchronously = true)]
        internal struct SlabAllocator : IAllocator, IDisposable
        {
            public AllocatorHandle Handle { get { return m_handle; } set { m_handle = value; } }

            public Allocator ToAllocator { get { return m_handle.ToAllocator; } }

            public bool IsCustomAllocator { get { return m_handle.IsCustomAllocator; } }

            internal AllocatorHandle m_handle;

            internal Block Storage;
            internal int Log2SlabSizeInBytes;
            internal FixedList4096Bytes<int> Occupied;
            internal long budgetInBytes;
            internal long allocatedBytes;

            public long BudgetInBytes => budgetInBytes;

            public long AllocatedBytes => allocatedBytes;

            internal int SlabSizeInBytes
            {
                get => 1 << Log2SlabSizeInBytes;
                set => Log2SlabSizeInBytes = (byte)(32 - math.lzcnt(math.max(1, value) - 1));
            }

            internal int Slabs => (int)(Storage.Bytes >> Log2SlabSizeInBytes);

            internal void Initialize(Block storage, int slabSizeInBytes, long budget)
            {   
#if ENABLE_UNITY_ALLOCATION_CHECKS
                storage.Range.Allocator.AddChildAllocator(Handle);
#endif
                Assert.IsTrue((slabSizeInBytes & (slabSizeInBytes - 1)) == 0);
                Storage = storage;
                Log2SlabSizeInBytes = 0;
                Occupied = default;
                budgetInBytes = budget;
                allocatedBytes = 0;
                SlabSizeInBytes = slabSizeInBytes;
                Occupied.Length = (Slabs + 31) / 32;
            }

            public int Try(ref Block block)
            {
                if (block.Range.Pointer == IntPtr.Zero) // Allocate
                {
                    if (block.Bytes + allocatedBytes > budgetInBytes)
                        return -2; //over allocator budget
                    if (block.Bytes > SlabSizeInBytes)
                        return -1;
                    for (var wordIndex = 0; wordIndex < Occupied.Length; ++wordIndex)
                    {
                        var word = Occupied[wordIndex];
                        if (word == -1)
                            continue;
                        for (var bitIndex = 0; bitIndex < 32; ++bitIndex)
                            if ((word & (1 << bitIndex)) == 0)
                            {
                                Occupied[wordIndex] |= 1 << bitIndex;
                                block.Range.Pointer = Storage.Range.Pointer +
                                    (int)(SlabSizeInBytes * (wordIndex * 32U + bitIndex));
                                block.AllocatedItems = SlabSizeInBytes / block.BytesPerItem;
                                allocatedBytes += block.Bytes;
                                return 0;
                            }
                    }

                    return -1;
                }

                if (block.Bytes == 0) // Free
                {
                    var slabIndex = ((ulong)block.Range.Pointer - (ulong)Storage.Range.Pointer) >>
                        Log2SlabSizeInBytes;
                    int wordIndex = (int)(slabIndex >> 5);
                    int bitIndex = (int)(slabIndex & 31);
                    Occupied[wordIndex] &= ~(1 << bitIndex);
                    block.Range.Pointer = IntPtr.Zero;
                    var blockSizeInBytes = block.AllocatedItems * block.BytesPerItem;
                    allocatedBytes -= blockSizeInBytes;
                    block.AllocatedItems = 0;
                    return 0;
                }

                // Reallocate (keep existing pointer and change size if possible. otherwise, allocate new thing and copy)
                return -1;
            }

            [BurstCompile(CompileSynchronously = true)]
			[MonoPInvokeCallback(typeof(TryFunction))]
            public static unsafe int Try(IntPtr allocatorState, ref Block block)
            {
                return ((SlabAllocator*)allocatorState)->Try(ref block);
            }

            public TryFunction Function => Try;

            public void Dispose()
            {
                m_handle.Rewind();
            }
        }

        internal struct TableEntry
        {
            internal IntPtr function;
            internal IntPtr state;
        }

        internal struct Array16<T> where T : unmanaged
        {
            internal T f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15;
        }
        internal struct Array256<T> where T : unmanaged
        {
            internal Array16<T> f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15;
        }
        internal struct Array4096<T> where T : unmanaged
        {
            internal Array256<T> f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15;
        }
        internal struct Array32768<T> : IIndexable<T> where T : unmanaged
        {
            internal Array4096<T> f0, f1, f2, f3, f4, f5, f6, f7;
            public int Length { get { return 32768; } set {} }
            public ref T ElementAt(int index)
            {
                unsafe { fixed(Array4096<T>* p = &f0) { return ref UnsafeUtility.AsRef<T>((T*)p + index); } }
            }
        }

        /// <summary>
        /// Contains arrays of the allocator function pointers.
        /// </summary>
        internal sealed class SharedStatics
        {
            internal sealed class IsInstalled { internal static readonly SharedStatic<Long1024> Ref = SharedStatic<Long1024>.GetOrCreate<IsInstalled>(); }
            internal sealed class TableEntry { internal static readonly SharedStatic<Array32768<AllocatorManager.TableEntry>> Ref = SharedStatic<Array32768<AllocatorManager.TableEntry>>.GetOrCreate<TableEntry>(); }
#if ENABLE_UNITY_ALLOCATION_CHECKS
            internal sealed class Version { internal static readonly SharedStatic<Array32768<ushort>> Ref = SharedStatic<Array32768<ushort>>.GetOrCreate<Version>(); }
            internal sealed class ChildSafetyHandles { internal static readonly SharedStatic<Array32768<UnsafeList<AtomicSafetyHandle>>> Ref = SharedStatic<Array32768<UnsafeList<AtomicSafetyHandle>>>.GetOrCreate<ChildSafetyHandles>(); }
            internal sealed class ChildAllocators { internal static readonly SharedStatic<Array32768<UnsafeList<AllocatorHandle>>> Ref = SharedStatic<Array32768<UnsafeList<AllocatorHandle>>>.GetOrCreate<ChildAllocators>(); }
            internal sealed class Parent { internal static readonly SharedStatic<Array32768<AllocatorHandle>> Ref = SharedStatic<Array32768<AllocatorHandle>>.GetOrCreate<Parent>(); }
            internal sealed class IndexInParent { internal static readonly SharedStatic<Array32768<int>> Ref = SharedStatic<Array32768<int>>.GetOrCreate<IndexInParent>(); }
#endif
        }

        internal static class Managed
        {
#if !UNITY_IOS
            /// <summary>
            /// Memory allocation status
            /// </summary>
            internal const int kMaxNumCustomAllocator = 32768;
            internal static TryFunction[] TryFunctionDelegates = new TryFunction[kMaxNumCustomAllocator];
#endif

            /// <summary>
            /// Register TryFunction delegates for managed caller to avoid garbage collections
            /// </summary>
            /// <param name="index">Index into the TryFunction delegates table.</param>
            /// <param name="function">TryFunction delegate to be registered.</param>
            [NotBurstCompatible]
            public static void RegisterDelegate(int index, TryFunction function)
            {
#if !UNITY_IOS
                if(index >= kMaxNumCustomAllocator)
                {
                    throw new ArgumentException("index to be registered in TryFunction delegate table exceeds maximum.");
                }
                // Register TryFunction delegates for managed caller to avoid garbage collections
                Managed.TryFunctionDelegates[index] = function;
#endif
            }

            /// <summary>
            /// Unregister TryFunction delegate
            /// </summary>
            /// <param name="int">Index into the TryFunction delegates table.</param>
            [NotBurstCompatible]
            public static void UnregisterDelegate(int index)
            {
#if !UNITY_IOS
                if (index >= kMaxNumCustomAllocator)
                {
                    throw new ArgumentException("index to be unregistered in TryFunction delegate table exceeds maximum.");
                }
                Managed.TryFunctionDelegates[index] = default;
#endif
            }
        }

        /// <summary>
        /// For internal use only.
        /// </summary>
        public static void Initialize()
        {
        }

        /// <summary>
        /// Saves an allocator's function pointers at a particular index in the global function table.
        /// </summary>
        /// <param name="handle">The global function table index at which to install the allocator function.</param>
        /// <param name="allocatorState">IntPtr to allocator's custom state.</param>
        /// <param name="functionPointer">The allocator function to install in the global function table.</param>
        /// <param name="function">The allocator function to install in the global function table.</param>
        internal static void Install(AllocatorHandle handle,
                                        IntPtr allocatorState,
                                        FunctionPointer<TryFunction> functionPointer,
                                        TryFunction function)
        {
            if(functionPointer.Value == IntPtr.Zero)
                handle.Unregister();
            else
            {
                int error = ConcurrentMask.TryAllocate(ref SharedStatics.IsInstalled.Ref.Data, handle.Value, 1);
                if (ConcurrentMask.Succeeded(error))
                {
                    handle.Install(new TableEntry { state = allocatorState, function = functionPointer.Value });
                    Managed.RegisterDelegate(handle.Index, function);
                }
            }
        }

        /// <summary>
        /// Saves an allocator's function pointers at a particular index in the global function table.
        /// </summary>
        /// <param name="handle">The global function table index at which to install the allocator function.</param>
        /// <param name="allocatorState">IntPtr to allocator's custom state.</param>
        /// <param name="function">The allocator function to install in the global function table.</param>
        internal static void Install(AllocatorHandle handle, IntPtr allocatorState, TryFunction function)
        {
            var functionPointer = (function == null)
                ? new FunctionPointer<TryFunction>(IntPtr.Zero)
                : BurstCompiler.CompileFunctionPointer(function);
            Install(handle, allocatorState, functionPointer, function);
        }

        /// <summary>
        /// Saves an allocator's function pointers in a free slot of the global function table. Thread safe.
        /// </summary>
        /// <param name="allocatorState">IntPtr to allocator's custom state.</param>
        /// <param name="functionPointer">Function pointer to create or save in the function table.</param>
        /// <returns>Returns a handle to the newly registered allocator function.</returns>
        internal static AllocatorHandle Register(IntPtr allocatorState, FunctionPointer<TryFunction> functionPointer)
        {
            var tableEntry = new TableEntry { state = allocatorState, function = functionPointer.Value };
            var error = ConcurrentMask.TryAllocate(ref SharedStatics.IsInstalled.Ref.Data, out int offset, (FirstUserIndex+63)>>6, SharedStatics.IsInstalled.Ref.Data.Length, 1);
            AllocatorHandle handle = default;
            if(ConcurrentMask.Succeeded(error))
            {
                handle.Index = (ushort)offset;
                handle.Install(tableEntry);
#if ENABLE_UNITY_ALLOCATION_CHECKS
                handle.Version = handle.OfficialVersion;
#endif
            }
            return handle;
        }

        /// <summary>
        /// Saves an allocator's function pointers in a free slot of the global function table. Thread safe.
        /// </summary>
        /// <typeparam name="T">The type of allocator to register.</typeparam>
        /// <param name="t">Reference to the allocator.</param>
        [NotBurstCompatible]
        public static unsafe void Register<T>(ref this T t) where T : unmanaged, IAllocator
        {
            var functionPointer = (t.Function == null)
                ? new FunctionPointer<TryFunction>(IntPtr.Zero)
                : BurstCompiler.CompileFunctionPointer(t.Function);
            t.Handle = Register((IntPtr)UnsafeUtility.AddressOf(ref t), functionPointer);

            Managed.RegisterDelegate(t.Handle.Index, t.Function);

#if ENABLE_UNITY_ALLOCATION_CHECKS
            if (!t.Handle.IsValid)
                throw new InvalidOperationException("Allocator registration succeeded, but failed to produce valid handle.");
#endif
        }

        /// <summary>
        /// Removes an allocator's function pointers from the global function table, without managed code
        /// </summary>
        /// <typeparam name="T">The type of allocator to unregister.</typeparam>
        /// <param name="t">Reference to the allocator.</param>
        public static void UnmanagedUnregister<T>(ref this T t) where T : unmanaged, IAllocator
        {
            if(t.Handle.IsInstalled)
            {
                t.Handle.Install(default);
                ConcurrentMask.TryFree(ref SharedStatics.IsInstalled.Ref.Data, t.Handle.Value, 1);
            }
        }

        /// <summary>
        /// Removes an allocator's function pointers from the global function table.
        /// </summary>
        /// <typeparam name="T">The type of allocator to unregister.</typeparam>
        /// <param name="t">Reference to the allocator.</param>
        [NotBurstCompatible]
        public static void Unregister<T>(ref this T t) where T : unmanaged, IAllocator
        {
            if(t.Handle.IsInstalled)
            {
                t.Handle.Install(default);
                ConcurrentMask.TryFree(ref SharedStatics.IsInstalled.Ref.Data, t.Handle.Value, 1);
                Managed.UnregisterDelegate(t.Handle.Index);
            }
        }

        /// <summary>
        /// Create a custom allocator by allocating a backing storage to store the allocator and then register it
        /// </summary>
        /// <typeparam name="T">The type of allocator to create.</typeparam>
        /// <param name="backingAllocator">Allocator used to allocate backing storage.</param>
        /// <returns>Returns reference to the newly created allocator.</returns>
        [NotBurstCompatible]
        internal static ref T CreateAllocator<T>(AllocatorHandle backingAllocator)
            where T : unmanaged, IAllocator
        {
            unsafe
            {
                var allocatorPtr = (T*)Memory.Unmanaged.Allocate(UnsafeUtility.SizeOf<T>(), 16, backingAllocator);
                *allocatorPtr = default;
                ref T allocator = ref UnsafeUtility.AsRef<T>(allocatorPtr);
                Register(ref allocator);
                return ref allocator;
            }
        }

        /// <summary>
        /// Destroy a custom allocator by unregistering the allocator and freeing its backing storage
        /// </summary>
        /// <typeparam name="T">The type of allocator to destroy.</typeparam>
        /// <param name="t">Reference to the allocator.</param>
        /// <param name="backingAllocator">Allocator used in allocating the backing storage.</param>
        [NotBurstCompatible]
        internal static void DestroyAllocator<T>(ref this T t, AllocatorHandle backingAllocator)
            where T : unmanaged, IAllocator
        {
            Unregister(ref t);

            unsafe
            {
                var allocatorPtr = UnsafeUtility.AddressOf<T>(ref t);
                Memory.Unmanaged.Free(allocatorPtr, backingAllocator);
            }
        }

        /// <summary>
        /// For internal use only.
        /// </summary>
        public static void Shutdown()
        {
        }

        /// <summary>
        /// Index in the global function table of the first user-defined allocator.
        /// </summary>
        /// <remarks>The indexes from 0 up to `FirstUserIndex` are reserved and so should not be used for your own allocators.</remarks>
        /// <value>Index in the global function table of the first user-defined allocator.</value>
        public const ushort FirstUserIndex = 64;

        internal static bool IsCustomAllocator(AllocatorHandle allocator)
        {
            return allocator.Index >= FirstUserIndex;
        }

        [Conditional("ENABLE_UNITY_ALLOCATION_CHECKS")]
        internal static void CheckFailedToAllocate(int error)
        {
            if (error != 0)
                throw new ArgumentException("failed to allocate");
        }

        [Conditional("ENABLE_UNITY_ALLOCATION_CHECKS")]
        internal static void CheckFailedToFree(int error)
        {
            if (error != 0)
                throw new ArgumentException("failed to free");
        }

        [Conditional("ENABLE_UNITY_ALLOCATION_CHECKS")]
        internal static void CheckValid(AllocatorHandle handle)
        {
#if ENABLE_UNITY_ALLOCATION_CHECKS
            if(handle.IsValid == false)
                throw new ArgumentException("allocator handle is not valid.");
#endif
        }
    }

    /// <summary>
    /// Provides a wrapper for custom allocator.
    /// </summary>
    [BurstCompatible(GenericTypeArguments = new[] { typeof(AllocatorManager.AllocatorHandle) })]
    public unsafe struct AllocatorHelper<T> : IDisposable
        where T : unmanaged, AllocatorManager.IAllocator
    {
        /// <summary>
        /// Pointer to a custom allocator.
        /// </summary>
        readonly T* m_allocator;

        /// <summary>
        /// Allocator used to allocate backing storage of T.
        /// </summary>
        AllocatorManager.AllocatorHandle m_backingAllocator;

        /// <summary>
        /// Get the custom allocator.
        /// </summary>
        public ref T Allocator => ref UnsafeUtility.AsRef<T>(m_allocator);

        /// <summary>
        /// Allocate the custom allocator from backingAllocator and register it.
        /// </summary>
        /// <param name="backingAllocator">Allocator used to allocate backing storage.</param>
        [NotBurstCompatible]
        public AllocatorHelper(AllocatorManager.AllocatorHandle backingAllocator)
        {
            ref var allocator = ref AllocatorManager.CreateAllocator<T>(backingAllocator);
            m_allocator = (T*)UnsafeUtility.AddressOf<T>(ref allocator);
            m_backingAllocator = backingAllocator;
        }

        /// <summary>
        /// Dispose the custom allocator backing memory and unregister it.
        /// </summary>
        [NotBurstCompatible]
        public void Dispose()
        {
            ref var allocator = ref UnsafeUtility.AsRef<T>(m_allocator);
            AllocatorManager.DestroyAllocator(ref allocator, m_backingAllocator);
        }
    }
}

#pragma warning restore 0649