Concurrent GPU access

Hi @Sergio0694!

I am trying to utilize a GPU for report building in my system, but when two users request a report at the same time, GPU access fails with the following error:

System.InvalidOperationException : Operations that change non-concurrent collections must have exclusive access. A concurrent update was performed on this collection and corrupted its state. The collection's state is no longer correct.

Is this expected? Does this mean that any instance of ComputeSharp.GraphicsDevice can be used from only one thread at a given moment of time?

Here is a simple reproduction scenario:

public void GpuMultiThread()
{
    int count = 10;
    List<Task> tasks = new List<Task>();

    for (int i = 0; i < count; i++)
    {
        int index = i;

        tasks.Add(Task.Run(() =>
        {
            ReadWriteBuffer<int> buffer = Gpu.Default.AllocateReadWriteBuffer<int>(count);

            Gpu.Default.For(count, thread =>
            {
                buffer[thread.X] = thread.X;
            });

            int sum = buffer.GetData().Sum();

            this.TestOutput.WriteLine($"Thread: {index}, sum: {sum}.");
        }));
    }

    Task.WhenAll(tasks).GetAwaiter().GetResult();
}

  Message: 
    System.ArgumentException : An item with the same key has already been added. Key: (39086322, 32, 1, 1)
  Stack Trace: 
    Dictionary`2.TryInsert(TKey key, TValue value, InsertionBehavior behavior)
    ShaderRunner.Run(GraphicsDevice device, Int32 x, Int32 y, Int32 z, Int32 threadsX, Int32 threadsY, Int32 threadsZ, Action`1 action)
    ShaderRunner.Run(GraphicsDevice device, Int32 x, Int32 y, Int32 z, Action`1 action)
    GraphicsDeviceExtensions.For(GraphicsDevice device, Int32 x, Action`1 action)

[Sergio0694]

Hey @miyconst - sorry for the delay, I finally have an update on this 😅

So, couple of things:

1. Turns out static constructors in C# are in fact thread-safe (see here, cc. @JimBobSquarePants FYI).

1. I’m doing a major refactoring of the whole library, moving away from lambda expressions to generic structs (similar to the value delegate approach we use in ImageSharp), which makes life a lot easier for the reflection system that creates the GPU shaders. In that branch, I’ve also made a fix for the concurrent accesses to the Gpu.Default property (here) - that property is now loaded directly from the static constructor, which should make it perfectly safe for concurrent access at any time. If you try that branch out (or just wait for the updated NuGet packages), let me know how it goes! That change should hopefully solve the issue you were having here.

[JimBobSquarePants]

Default property is initialized in the static constructor, which is not thread safe), you might end up with different GPU instances if two threads are accessing the Default property at the same time.

Lazy<T>?