public KalkNativeBuffer(byte[] buffer)
{
_buffer = new SharedBuffer(buffer.Length);
buffer.CopyTo(_buffer.AsSpan());
_offset = 0;
_length = _buffer.Length;
}
void ISender.Send(SharedBuffer buffer, ApiStatus status)
{
if (this.Send != null)
{
this.Send(buffer, status);
}
}
public static SharedBuffer CreateBuffer(Guid id, Type elementType, long bufferSize)
{
var sb = new SharedBuffer();
sb.Id = id;
sb.ElementTypeString = elementType.FullName;
sb.ElementSize = Marshal.SizeOf(elementType);
sb.ElementCount = bufferSize;
if (_blockPath != string.Empty)
{
var fileStream = System.IO.File.Create(string.Format(@"{0}\{1}", _blockPath, id.ToString()),
(int)(bufferSize * sb.ElementSize), System.IO.FileOptions.DeleteOnClose);
var mmf = MemoryMappedFile.CreateFromFile(fileStream, id.ToString(),
(int)(bufferSize * sb.ElementSize),
MemoryMappedFileAccess.ReadWrite, null, System.IO.HandleInheritability.None, false);
_cacheBuffers.TryAdd(id, sb);
_cacheMmfs.TryAdd(id, mmf);
_cacheFileStreams.TryAdd(id, fileStream);
}
else
{
var mmf = MemoryMappedFile.CreateNew(id.ToString(),
bufferSize * sb.ElementSize);
_cacheBuffers.TryAdd(id, sb);
_cacheMmfs.TryAdd(id, mmf);
}
return(sb);
}
protected override Task SendAsync(SharedBuffer buffer)
{
if (this.Send != null)
{
return(this.Send(buffer, this.RaiseBackgroundError));
}
return(Task.CompletedTask);
}
public KalkNativeBuffer(IEnumerable <byte> buffer)
{
var array = new List <byte>(buffer).ToArray();;
_buffer = new SharedBuffer(array.Length);
array.CopyTo(_buffer.AsSpan());
_offset = 0;
_length = _buffer.Length;
}
public KalkNativeBuffer(int size)
{
if (size < 0)
{
throw new ArgumentOutOfRangeException(nameof(size));
}
_buffer = new SharedBuffer(size);
_offset = 0;
_length = size;
}
/// <summary>
///
/// </summary>
/// <param name="sb"></param>
public void PrefetchBuffer(SharedBuffer sb)
{
if ((!_sbStack.Any(sbOther => sbOther.Id.CompareTo(sb.Id) == 0)) &&
(!_sbDone.Any(sbOther => sbOther.Id.CompareTo(sb.Id) == 0)))
{
_sbStack.Push(sb);
}
if (_sbPrefetchTask == null ||
_sbPrefetchTask.Status != System.Threading.Tasks.TaskStatus.Running)
{
Action prefetchAction = () =>
{
try
{
while (true)
{
SharedBuffer sbLocal;
if (_sbStack.TryPop(out sbLocal))
{
#if SLOW_POKE
var handle = sbLocal.GetHandle();
const long STEP_SIZE = 4096;
long numSteps = (long)handle.ByteLength / STEP_SIZE;
System.Threading.Tasks.Parallel.For(0, numSteps,
at => handle.Read <byte>((ulong)(at * STEP_SIZE)));
sbLocal.ReleaseHandle();
#else
BufferRepository.ReadFile(sbLocal.Id);
#endif
_sbDone.Add(sbLocal);
}
else
{
System.Threading.Thread.Sleep(1000);
}
}
}
finally
{
System.Console.WriteLine("Exiting prefetch...");
}
};
_sbPrefetchTask = new System.Threading.Tasks.Task(prefetchAction);
_sbPrefetchTask.Start();
}
}
private static int InvokeSend(IntPtr managed_handle, IntPtr buffer, IntPtr status)
{
return(SenderAdapter.InvokeAndUnwrapExceptions(
(ApiStatus apiStatus) =>
{
SenderAdapter adapter = GetAdapterOrThrow(managed_handle);
SharedBuffer sharedBuffer = new SharedBuffer(buffer);
// Buffer must live at least as long as the underlying call.
unsafe {
adapter.senderImplementation.Send(sharedBuffer, apiStatus);
}
return apiStatus.ErrorCode;
},
status
));
}
public override void Init()
{
base.Init();
GenerateQuad();
var shader = Resources.Load <Shader>("shaders/raytracing.shader");
storageTex = Texture.CreateStorage(2048, 2048, VkFormat.R8G8B8A8SNorm);
uniformBuffer = new SharedBuffer(VkBufferUsageFlags.UniformBuffer, (uint)Utilities.SizeOf <UboCompute>());
material = new Material(shader);
material.SetTexture("samplerColor", storageTex);
computePipeline = shader.GetPass("Compute");
computeResourceSet = new DescriptorSet(computePipeline.PipelineLayout.ResourceLayout[0], storageTex, uniformBuffer);
renderer.AddComputePass(Docompute);
renderer.AddGraphicsPass(DrawQuad);
MainView.Attach(null, null, renderer);
}
public ShareEnumerator(SharedBuffer <T> parent)
{
_parent = parent;
}
private KalkNativeBuffer(SharedBuffer buffer, int offset, int length)
{
_buffer = buffer;
_offset = offset;
_length = length;
}
public ShareEnumerator(SharedBuffer <T> parent)
{
_parent = parent;
Current = default !;
public void TestSum()
{
int[] numbers = Enumerable.Range(999, 10000).ToArray();
using (CudaManager cudaManager = Provider.CudaManagerPool.GetCudaManagerForThread(Provider.Logger))
using (CudaArray <int> numbersBuffer = numbers)
using (CudaArray <int> outputBuffer = new[] { 0 }) {
KernelManager kernels = new KernelManager(cudaManager);
for (int nBlocks = 1; nBlocks <= 1024; nBlocks *= 2)
{
for (int threadsPerBlock = 1; threadsPerBlock <= 1024; threadsPerBlock *= 2)
{
kernels["setIntKernel"].Arguments(outputBuffer, 0).ExecuteTask();
Assert.AreEqual(0, outputBuffer.Read()[0]);
kernels["sumToOutputKernel"].Arguments(numbersBuffer, numbers.Length, outputBuffer, SharedBuffer.Ints(threadsPerBlock)).Execute(nBlocks * threadsPerBlock, threadsPerBlock);
Assert.AreEqual(numbers.Sum(), outputBuffer.Read()[0]);
}
}
}
}
