Add a CPU-GPU-Shared MemoryBuffer for systems that support it about ilgpu HOT 2 CLOSED

using ILGPU;
using ILGPU.Runtime;
using ILGPU.Runtime.OpenCL;
using ILGPU.Util;
using System;

namespace CLHostMemory
{
    class Program
    {
        static void MyKernel(
            Index1D index,
            ArrayView<int> dataView,
            int constant)
        {
            dataView[index] = index + constant;
        }

        static void Main()
        {
            // Create main context
            using var context = Context.CreateDefault();
            using var accelerator = context.CreateCLAccelerator(0);

            var kernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<int>, int>(MyKernel);

            using var buffer = accelerator.AllocateHostMemory<int>(1024);
            var bufferView = new ArrayView<int>(buffer, 0, buffer.Length);
            var bufferView1D = new ArrayView1D<int, Stride1D.Dense>(bufferView, bufferView.Extent, new Stride1D.Dense());

            kernel((int)buffer.Length, bufferView1D, 42);

            var data = bufferView1D.GetAsArray1D();
            for (int i = 0, e = data.Length; i < e; ++i)
            {
                if (data[i] != 42 + i)
                    Console.WriteLine($"Error at element location {i}: {data[i]} found");
            }
        }
    }

    class CLHostMemoryBuffer<T> : MemoryBuffer
        where T : unmanaged
    {
        public CLHostMemoryBuffer(
            CLAccelerator accelerator,
            long length,
            int elementSize)
            : base(accelerator, length, elementSize)
        {
            CLException.ThrowIfFailed(
                CLAPI.CurrentAPI.CreateBuffer(
                    accelerator.NativePtr,
                    CLBufferFlags.CL_MEM_ALLOC_HOST_PTR,
                    new IntPtr(LengthInBytes),
                    IntPtr.Zero,
                    out IntPtr resultPtr));
            NativePtr = resultPtr;
        }

        protected override void DisposeAcceleratorObject(bool disposing)
        {
            if (disposing)
                CLException.ThrowIfFailed(CLAPI.CurrentAPI.ReleaseBuffer(NativePtr));
            NativePtr = IntPtr.Zero;
        }

        protected override void CopyFrom(
            AcceleratorStream stream,
            in ArrayView<byte> sourceView,
            in ArrayView<byte> targetView) =>
            CLMemoryBuffer.CLCopy(stream.AsNotNullCast<CLStream>(), sourceView, targetView);

        protected override void CopyTo(
            AcceleratorStream stream,
            in ArrayView<byte> sourceView,
            in ArrayView<byte> targetView) =>
            CLMemoryBuffer.CLCopy(stream.AsNotNullCast<CLStream>(), sourceView, targetView);

        protected override void MemSet(
            AcceleratorStream stream,
            byte value,
            in ArrayView<byte> targetView) =>
            CLMemoryBuffer.CLMemSet(stream.AsNotNullCast<CLStream>(), value, targetView);
    }

    static class CLHostMemoryExtensions
    {
        public static CLHostMemoryBuffer<T> AllocateHostMemory<T>(this CLAccelerator accelerator, long length)
            where T : unmanaged =>
            new CLHostMemoryBuffer<T>(accelerator, length, Interop.SizeOf<T>());
    }
}