using NUnit.Framework;
using UnityEngine;
using Unity.Collections.LowLevel.Unsafe;
using Unity.PerformanceTesting;
using Unity.PerformanceTesting.Benchmark;
using System.Runtime.CompilerServices;
using System.Threading;

namespace Unity.Collections.PerformanceTests
{
    static class ParallelHashMapUtil
    {
        static public void AllocInt(ref NativeParallelHashMap<int, int> container, int capacity, bool addValues)
        {
            if (capacity >= 0)
            {
                Unity.Mathematics.Random random = new Unity.Mathematics.Random(HashMapUtil.K_RANDOM_SEED_1);
                container = new NativeParallelHashMap<int, int>(capacity, Allocator.Persistent);
                if (addValues)
                {
                    int keysAdded = 0;

                    while (keysAdded < capacity)
                    {
                        int randKey = random.NextInt();
                        if (container.TryAdd(randKey, keysAdded))
                        {
                            ++keysAdded;
                        }
                    }
                }
            }
            else
                container.Dispose();
        }
        static public void AllocInt(ref UnsafeParallelHashMap<int, int> container, int capacity, bool addValues)
        {
            if (capacity >= 0)
            {
                Unity.Mathematics.Random random = new Unity.Mathematics.Random(HashMapUtil.K_RANDOM_SEED_1);
                container = new UnsafeParallelHashMap<int, int>(capacity, Allocator.Persistent);
                if (addValues)
                {
                    int keysAdded = 0;

                    while (keysAdded < capacity)
                    {
                        int randKey = random.NextInt();
                        if (container.TryAdd(randKey, keysAdded))
                        {
                            ++keysAdded;
                        }
                    }
                }
            }
            else
                container.Dispose();
        }
        static public object AllocBclContainer(int capacity, bool addValues)
        {
            if (capacity < 0)
                return null;

            Unity.Mathematics.Random random = new Unity.Mathematics.Random(HashMapUtil.K_RANDOM_SEED_1);

            // FROM MICROSOFT DOCUMENTATION
            // The higher the concurrencyLevel, the higher the theoretical number of operations
            // that could be performed concurrently on the ConcurrentDictionary.  However, global
            // operations like resizing the dictionary take longer as the concurrencyLevel rises.
            // For the purposes of this example, we'll compromise at numCores * 2.
            var bclContainer = new System.Collections.Concurrent.ConcurrentDictionary<int, int>(System.Environment.ProcessorCount * 2, capacity);

            if (addValues)
            {
                int keysAdded = 0;

                while (keysAdded < capacity)
                {
                    int randKey = random.NextInt();
                    if (bclContainer.TryAdd(randKey, keysAdded))
                    {
                        ++keysAdded;
                    }
                }
            }
            return bclContainer;
        }
        static public void CreateRandomKeys(int capacity, ref UnsafeList<int> keys)
        {
            if (capacity >= 0)
            {
                keys = new UnsafeList<int>(capacity, Allocator.Persistent);
                using (UnsafeHashSet<int> randomFilter = new UnsafeHashSet<int>(capacity, Allocator.Persistent))
                {
                    Unity.Mathematics.Random random = new Unity.Mathematics.Random(HashMapUtil.K_RANDOM_SEED_2);
                    int keysAdded = 0;

                    while (keysAdded < capacity)
                    {
                        int randKey = random.NextInt();
                        if (randomFilter.Add(randKey))
                        {
                            keys.Add(randKey);
                            ++keysAdded;
                        }
                    }
                }
            }
            else
                keys.Dispose();
        }

        static public void CreateRandomKeys(int capacity, ref UnsafeList<int> keys, ref UnsafeParallelHashMap<int, int> hashMap)
        {
            if (capacity >= 0)
            {
                keys = new UnsafeList<int>(capacity, Allocator.Persistent);
                using (UnsafeHashSet<int> randomFilter = new UnsafeHashSet<int>(capacity, Allocator.Persistent))
                {
                    Unity.Mathematics.Random random = new Unity.Mathematics.Random(HashMapUtil.K_RANDOM_SEED_2);
                    int keysAdded = 0;

                    while (keysAdded < capacity)
                    {
                        int randKey = random.NextInt();
                        if (randomFilter.Add(randKey))
                        {
                            keys.Add(randKey);
                            ++keysAdded;
                        }
                    }
                }

            }
            else
                keys.Dispose();
        }

        static public void CreateRandomKeys(int capacity, ref UnsafeList<int> keys, ref System.Collections.Concurrent.ConcurrentDictionary<int, int> hashMap)
        {
            if (capacity >= 0)
            {
                keys = new UnsafeList<int>(capacity, Allocator.Persistent);
                using (UnsafeHashSet<int> randomFilter = new UnsafeHashSet<int>(capacity, Allocator.Persistent))
                {
                    Unity.Mathematics.Random random = new Unity.Mathematics.Random(HashMapUtil.K_RANDOM_SEED_2);
                    int keysAdded = 0;

                    while (keysAdded < capacity)
                    {
                        int randKey = random.NextInt();
                        if (randomFilter.Add(randKey))
                        {
                            keys.Add(randKey);
                            ++keysAdded;
                        }
                    }
                }

            }
            else
                keys.Dispose();
        }

        static public void CreateRandomKeys(int capacity, ref UnsafeList<int> keys, ref NativeParallelHashMap<int, int> hashMap)
        {
            if (capacity >= 0)
            {
                keys = new UnsafeList<int>(capacity, Allocator.Persistent);
                using (UnsafeHashSet<int> randomFilter = new UnsafeHashSet<int>(capacity, Allocator.Persistent))
                {
                    Unity.Mathematics.Random random = new Unity.Mathematics.Random(HashMapUtil.K_RANDOM_SEED_2);
                    int keysAdded = 0;

                    while (keysAdded < capacity)
                    {
                        int randKey = random.NextInt();
                        if (randomFilter.Add(randKey))
                        {
                            keys.Add(randKey);
                            ++keysAdded;
                        }
                    }
                }

            }
            else
                keys.Dispose();
        }

        static public void RandomlyShuffleKeys(int capacity, ref UnsafeList<int> keys)
        {
            if (capacity >= 0)
            {
                Unity.Mathematics.Random random = new Mathematics.Random(HashMapUtil.K_RANDOM_SEED_3);
                for (int i = 0; i < capacity; i++)
                {
                    int keyAt = keys[i];
                    int randomIndex = random.NextInt(0, capacity - 1);
                    keys[i] = keys[randomIndex];
                    keys[randomIndex] = keyAt;
                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static public void SplitForWorkers(int count, int worker, int workers, out int startInclusive, out int endExclusive)
        {
            startInclusive = count * worker / workers;
            endExclusive = count * (worker + 1) / workers;
        }
    }

    struct ParallelHashMapIsEmpty100k : IBenchmarkContainerParallel
    {
        const int kIterations = 100_000;
        int workers;
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;

        void IBenchmarkContainerParallel.SetParams(int capacity, params int[] args) => workers = args[0];
        public void AllocNativeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, true);
        public void AllocUnsafeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, true);
        public object AllocBclContainer(int capacity) => ParallelHashMapUtil.AllocBclContainer(capacity, true);

        [MethodImpl(MethodImplOptions.NoOptimization)]
        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var reader = nativeContainer.AsReadOnly();
            ParallelHashMapUtil.SplitForWorkers(kIterations, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                _ = reader.IsEmpty;
        }
        [MethodImpl(MethodImplOptions.NoOptimization)]
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            ParallelHashMapUtil.SplitForWorkers(kIterations, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                _ = unsafeContainer.IsEmpty;
        }
        [MethodImpl(MethodImplOptions.NoOptimization)]
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.SplitForWorkers(kIterations, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                _ = bclContainer.IsEmpty;
        }
    }

    struct ParallelHashMapCount100k : IBenchmarkContainerParallel
    {
        const int kIterations = 100_000;
        int workers;
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;

        void IBenchmarkContainerParallel.SetParams(int capacity, params int[] args) => workers = args[0];
        public void AllocNativeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, true);
        public void AllocUnsafeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, true);
        public object AllocBclContainer(int capacity) => ParallelHashMapUtil.AllocBclContainer(capacity, true);

        [MethodImpl(MethodImplOptions.NoOptimization)]
        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var reader = nativeContainer.AsReadOnly();
            ParallelHashMapUtil.SplitForWorkers(kIterations, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                _ = reader.Count();
        }
        [MethodImpl(MethodImplOptions.NoOptimization)]
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            ParallelHashMapUtil.SplitForWorkers(kIterations, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                _ = unsafeContainer.Count();
        }
        [MethodImpl(MethodImplOptions.NoOptimization)]
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.SplitForWorkers(kIterations, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                _ = bclContainer.Count;
        }
    }

    struct ParallelHashMapToNativeArrayKeys : IBenchmarkContainerParallel
    {
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;

        public void AllocNativeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, true);
        public void AllocUnsafeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, true);
        public object AllocBclContainer(int capacity) => ParallelHashMapUtil.AllocBclContainer(capacity, true);

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var asArray = nativeContainer.GetKeyArray(Allocator.Temp);
            asArray.Dispose();
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            var asArray = unsafeContainer.GetKeyArray(Allocator.Temp);
            asArray.Dispose();
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            int[] asArray = new int[bclContainer.Count];
            bclContainer.Keys.CopyTo(asArray, 0);
        }
    }

    struct ParallelHashMapToNativeArrayValues : IBenchmarkContainerParallel
    {
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;

        public void AllocNativeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, true);
        public void AllocUnsafeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, true);
        public object AllocBclContainer(int capacity) => ParallelHashMapUtil.AllocBclContainer(capacity, true);

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var asArray = nativeContainer.GetValueArray(Allocator.Temp);
            asArray.Dispose();
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            var asArray = unsafeContainer.GetValueArray(Allocator.Temp);
            asArray.Dispose();
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            int[] asArray = new int[bclContainer.Count];
            bclContainer.Values.CopyTo(asArray, 0);
        }
    }

    struct ParallelHashMapInsert : IBenchmarkContainerParallel
    {
        int capacity;
        int workers;
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;
        UnsafeList<int> keys;

        void IBenchmarkContainerParallel.SetParams(int capacity, params int[] args)
        {
            this.capacity = capacity;
            workers = args[0];
        }

        public void AllocNativeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
        }

        public void AllocUnsafeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
        }

        public object AllocBclContainer(int capacity)
        {
            object container = ParallelHashMapUtil.AllocBclContainer(capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            return container;
        }

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var writer = nativeContainer.AsParallelWriter();
            ParallelHashMapUtil.SplitForWorkers(capacity, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                writer.TryAdd(keys[i], i, threadIndex);
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            var writer = unsafeContainer.AsParallelWriter();
            ParallelHashMapUtil.SplitForWorkers(capacity, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                writer.TryAdd(keys[i], i, threadIndex);
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.SplitForWorkers(capacity, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
                bclContainer.TryAdd(keys[i], i);
        }
    }

    struct ParallelHashMapAddGrow : IBenchmarkContainerParallel
    {
        int capacity;
        int toAdd;
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;
        UnsafeList<int> keys;

        void IBenchmarkContainerParallel.SetParams(int capacity, params int[] args)
        {
            this.capacity = capacity;
            toAdd = args[0] - capacity;
        }

        public void AllocNativeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, true);
            int toAddCount = capacity < 0 ? -1 : toAdd;
            ParallelHashMapUtil.CreateRandomKeys(toAddCount, ref keys, ref nativeContainer);
        }

        public void AllocUnsafeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, true);
            int toAddCount = capacity < 0 ? -1 : toAdd;
            ParallelHashMapUtil.CreateRandomKeys(toAddCount, ref keys, ref unsafeContainer);
        }

        public object AllocBclContainer(int capacity)
        {
            object container = ParallelHashMapUtil.AllocBclContainer(capacity, true);
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            int toAddCount = capacity < 0 ? -1 : toAdd;
            ParallelHashMapUtil.CreateRandomKeys(toAddCount, ref keys, ref bclContainer);
            return container;
        }

        public void MeasureNativeContainer(int _, int __)
        {
            // Intentionally setting capacity small and growing by adding more items
            for (int i = 0; i < toAdd; i++)
                nativeContainer.Add(keys[i], i);
        }
        public void MeasureUnsafeContainer(int _, int __)
        {
            // Intentionally setting capacity small and growing by adding more items
            for (int i = 0; i < toAdd; i++)
                unsafeContainer.Add(keys[i], i);
        }
        public void MeasureBclContainer(object container, int _)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            // Intentionally setting capacity small and growing by adding more items
            for (int i = 0; i < toAdd; i++)
                bclContainer.TryAdd(keys[i], i);
        }
    }

    struct ParallelHashMapContains : IBenchmarkContainerParallel
    {
        int capacity;
        int workers;
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;
        UnsafeList<int> keys;

        void IBenchmarkContainerParallel.SetParams(int capacity, params int[] args)
        {
            this.capacity = capacity;
            workers = args[0];
        }

        public void AllocNativeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                nativeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public void AllocUnsafeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                unsafeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public object AllocBclContainer(int capacity)
        {
            object container = ParallelHashMapUtil.AllocBclContainer(capacity, false);
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                bclContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
            return container;
        }

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var reader = nativeContainer.AsReadOnly();
            ParallelHashMapUtil.SplitForWorkers(capacity, worker, workers, out int start, out int end);
            bool data = false;
            for (int i = start; i < end; i++)
                Volatile.Write(ref data, reader.ContainsKey(keys[i]));
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            ParallelHashMapUtil.SplitForWorkers(capacity, worker, workers, out int start, out int end);
            bool data = false;
            for (int i = start; i < end; i++)
                Volatile.Write(ref data, unsafeContainer.ContainsKey(keys[i]));
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.SplitForWorkers(capacity, worker, workers, out int start, out int end);
            bool data = false;
            for (int i = start; i < end; i++)
                Volatile.Write(ref data, bclContainer.ContainsKey(keys[i]));
        }
    }

    struct ParallelHashMapIndexedRead : IBenchmarkContainerParallel
    {
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;
        UnsafeList<int> keys;

        public void AllocNativeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                nativeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public void AllocUnsafeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                unsafeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public object AllocBclContainer(int capacity)
        {
            object container = ParallelHashMapUtil.AllocBclContainer(capacity, false);
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                bclContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
            return container;
        }

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var reader = nativeContainer.AsReadOnly();
            int insertions = keys.Length;
            int value = 0;
            for (int i = 0; i < insertions; i++)
                Volatile.Write(ref value, reader[keys[i]]);
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            int insertions = keys.Length;
            int value = 0;
            for (int i = 0; i < insertions; i++)
                Volatile.Write(ref value, unsafeContainer[keys[i]]);
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            int insertions = keys.Length;
            int value = 0;
            for (int i = 0; i < insertions; i++)
                Volatile.Write(ref value, bclContainer[keys[i]]);
        }
    }

    struct ParallelHashMapIndexedWrite : IBenchmarkContainerParallel
    {
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;
        UnsafeList<int> keys;

        public void AllocNativeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                nativeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public void AllocUnsafeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                unsafeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public object AllocBclContainer(int capacity)
        {
            object container = ParallelHashMapUtil.AllocBclContainer(capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            for (int i = 0; i < capacity; i++)
                bclContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
            return container;
        }

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            int insertions = keys.Length;
            for (int i = 0; i < insertions; i++)
                nativeContainer[keys[i]] = i;
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            int insertions = keys.Length;
            for (int i = 0; i < insertions; i++)
                unsafeContainer[keys[i]] = i;
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            int insertions = keys.Length;
            for (int i = 0; i < insertions; i++)
                bclContainer[keys[i]] = i;
        }
    }

    struct ParallelHashMapTryGetValue : IBenchmarkContainerParallel
    {
        int workers;
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;
        UnsafeList<int> keys;

        void IBenchmarkContainerParallel.SetParams(int capacity, params int[] args) => workers = args[0];

        public void AllocNativeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                nativeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public void AllocUnsafeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                unsafeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public object AllocBclContainer(int capacity)
        {
            object container = ParallelHashMapUtil.AllocBclContainer(capacity, false);
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                bclContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
            return container;
        }

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            var reader = nativeContainer.AsReadOnly();
            ParallelHashMapUtil.SplitForWorkers(keys.Length, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
            {
                reader.TryGetValue(keys[i], out var value);
                Volatile.Read(ref value);
            }
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            ParallelHashMapUtil.SplitForWorkers(keys.Length, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
            {
                unsafeContainer.TryGetValue(keys[i], out var value);
                Volatile.Read(ref value);
            }
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.SplitForWorkers(keys.Length, worker, workers, out int start, out int end);
            for (int i = start; i < end; i++)
            {
                bclContainer.TryGetValue(keys[i], out var value);
                Volatile.Read(ref value);
            }
        }
    }

    struct ParallelHashMapRemove : IBenchmarkContainerParallel
    {
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;
        UnsafeList<int> keys;

        public void AllocNativeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                nativeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public void AllocUnsafeContainer(int capacity)
        {
            ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, false);
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                unsafeContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
        }
        public object AllocBclContainer(int capacity)
        {
            object container = ParallelHashMapUtil.AllocBclContainer(capacity, false);
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            ParallelHashMapUtil.CreateRandomKeys(capacity, ref keys);
            for (int i = 0; i < capacity; i++)
                bclContainer.TryAdd(keys[i], i);
            ParallelHashMapUtil.RandomlyShuffleKeys(capacity, ref keys);
            return container;
        }

        public void MeasureNativeContainer(int worker, int threadIndex)
        {
            int insertions = keys.Length;
            for (int i = 0; i < insertions; i++)
                nativeContainer.Remove(keys[i]);
        }
        public void MeasureUnsafeContainer(int worker, int threadIndex)
        {
            int insertions = keys.Length;
            for (int i = 0; i < insertions; i++)
                unsafeContainer.Remove(keys[i]);
        }
        public void MeasureBclContainer(object container, int worker)
        {
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            int insertions = keys.Length;
            for (int i = 0; i < insertions; i++)
                bclContainer.TryRemove(keys[i], out _);
        }
    }

    struct ParallelHashMapForEach : IBenchmarkContainerParallel
    {
        NativeParallelHashMap<int, int> nativeContainer;
        UnsafeParallelHashMap<int, int> unsafeContainer;

        public void AllocNativeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref nativeContainer, capacity, true);
        public void AllocUnsafeContainer(int capacity) => ParallelHashMapUtil.AllocInt(ref unsafeContainer, capacity, true);
        public object AllocBclContainer(int capacity) => ParallelHashMapUtil.AllocBclContainer(capacity, true);

        public void MeasureNativeContainer(int _, int __)
        {
            foreach (var pair in nativeContainer)
                Volatile.Read(ref pair.Value);
        }
        public void MeasureUnsafeContainer(int _, int __)
        {
            foreach (var pair in unsafeContainer)
                Volatile.Read(ref pair.Value);
        }
        public void MeasureBclContainer(object container, int _)
        {
            int value = 0;
            var bclContainer = (System.Collections.Concurrent.ConcurrentDictionary<int, int>)container;
            foreach (var pair in bclContainer)
                Volatile.Write(ref value, pair.Value);
        }
    }


    [Benchmark(typeof(BenchmarkContainerType))]
    [BenchmarkNameOverride(BenchmarkContainerConfig.BCL, "ConcurrentDictionary")]
    class ParallelHashMap
    {
#if UNITY_EDITOR
        [UnityEditor.MenuItem(BenchmarkContainerConfig.kMenuItemIndividual + nameof(ParallelHashMap))]
        static void RunIndividual()
            => BenchmarkContainerConfig.RunBenchmark(typeof(ParallelHashMap));
#endif

        [Test, Performance]
        [Category("Performance")]
        public unsafe void IsEmpty_x_100k(
            [Values(1, 2, 4)] int workers,
            [Values(0, 100)] int capacity,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapIsEmpty100k>.Run(workers, capacity, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void Count_x_100k(
            [Values(1, 2, 4)] int workers,
            [Values(0, 100)] int capacity,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapCount100k>.Run(workers, capacity, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void ToNativeArrayKeys(
            [Values(1)] int workers,
            [Values(10000, 100000, 1000000)] int capacity,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapToNativeArrayKeys>.Run(workers, capacity, type);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void ToNativeArrayValues(
            [Values(1)] int workers,
            [Values(10000, 100000, 1000000)] int capacity,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapToNativeArrayValues>.Run(workers, capacity, type);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void Insert(
            [Values(1, 2, 4)] int workers,
#if UNITY_STANDALONE || UNITY_EDITOR
            [Values(10000, 100000, 1000000)] int insertions,
#else
            [Values(10000, 100000)] int insertions,  // Observe potential lower memory requirement on non-desktop platforms
#endif
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapInsert>.Run(workers, insertions, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        [BenchmarkTestFootnote("Incrementally grows from `capacity` until reaching size of `growTo`")]
        public unsafe void AddGrow(
            [Values(1)] int workers,  // Can't grow capacity in parallel
            [Values(4, 65536)] int capacity,
            [Values(1024 * 1024)] int growTo,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapAddGrow>.Run(workers, capacity, type, growTo);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void Contains(
            [Values(1, 2, 4)] int workers,
#if UNITY_STANDALONE || UNITY_EDITOR
            [Values(10000, 100000, 1000000)] int insertions,
#else
            [Values(10000, 100000)] int insertions,  // Observe potential lower memory requirement on non-desktop platforms
#endif
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapContains>.Run(workers, insertions, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void IndexedRead(
            [Values(1, 2, 4)] int workers,
#if UNITY_STANDALONE || UNITY_EDITOR
            [Values(10000, 100000, 1000000)] int insertions,
#else
            [Values(10000, 100000)] int insertions,  // Observe potential lower memory requirement on non-desktop platforms
#endif
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapIndexedRead>.Run(workers, insertions, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void IndexedWrite(
            [Values(1)] int workers,  // Indexed write only available in single thread
            [Values(10000, 100000, 1000000)] int insertions,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapIndexedWrite>.Run(workers, insertions, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void TryGetValue(
            [Values(1, 2, 4)] int workers,
#if UNITY_STANDALONE || UNITY_EDITOR
            [Values(10000, 100000, 1000000)] int insertions,
#else
            [Values(10000, 100000)] int insertions,  // Observe potential lower memory requirement on non-desktop platforms
#endif
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapTryGetValue>.Run(workers, insertions, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void Remove(
            [Values(1)] int workers,  // No API for ParallelWriter.TryRemove currently
            [Values(10000, 100000, 1000000)] int insertions,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapRemove>.Run(workers, insertions, type, workers);
        }

        [Test, Performance]
        [Category("Performance")]
        public unsafe void Foreach(
            [Values(1)] int workers,  // This work can't be split
            [Values(10000, 100000, 1000000)] int insertions,
            [Values] BenchmarkContainerType type)
        {
            BenchmarkContainerRunnerParallel<ParallelHashMapForEach>.Run(workers, insertions, type, workers);
        }
    }
}