public bool BindBufferToOutputTensor(Interpreter interpreter, int index, ComputeBuffer buffer)
{
uint bufferID = (uint)buffer.GetNativeBufferPtr().ToInt32();
var status = TfLiteGpuDelegateV2BindOutputBuffer(Delegate, index, bufferID);
return(status == Interpreter.Status.Ok);
}
public void GetD3D11DeviceTest()
{
ComputeBuffer buffer = new ComputeBuffer(1, 4);
IntPtr device = FlexUtils.DeviceFromResource(buffer.GetNativeBufferPtr());
buffer.Release();
Assert.AreNotEqual(default(IntPtr), device);
}
/// <summary>
///
/// </summary>
/// <param name="buffer"></param>
/// <param name="data"></param>
/// <returns></returns>
public static Status RetrieveBufferData(ComputeBuffer buffer, byte[] data)
{
if (buffer == null)
{
return(Status.InvalidArguments);
}
return((Status)RetrieveBufferData(buffer.GetNativeBufferPtr(), data));
}
/// <summary>
///
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static Status RequestBufferData(ComputeBuffer buffer)
{
if (buffer == null)
{
return(Status.InvalidArguments);
}
return((Status)RequestBufferData(buffer.GetNativeBufferPtr()));
}
private bool BindBufferToTensor(int tensorIndex, ComputeBuffer buffer)
{
Debug.Assert(buffer.IsValid());
Debug.Assert(Delegate != TfLiteDelegate.Zero);
uint bufferID = (uint)buffer.GetNativeBufferPtr().ToInt32();
var status = TfLiteGpuDelegateBindBufferToTensor(Delegate, bufferID, tensorIndex);
return(status == Interpreter.Status.Ok);
}
private static IntPtr GetBufferPtr(ComputeBuffer buffer)
{
IntPtr ptr;
if (_bufferHandles.TryGetValue(buffer, out ptr))
return ptr;
ptr = buffer.GetNativeBufferPtr();
_bufferHandles.Add(buffer, ptr);
return ptr;
}
private static IntPtr GetBufferPtr(ComputeBuffer buffer)
{
if (_bufferHandles.TryGetValue(buffer, out IntPtr ptr))
{
return(ptr);
}
ptr = buffer.GetNativeBufferPtr();
_bufferHandles.Add(buffer, ptr);
return(ptr);
}
static public IntPtr GetFor(ComputeBuffer rt)
{
if (cbPtrs.ContainsKey(rt))
{
return(cbPtrs[rt]);
}
else
{
var ptr = rt.GetNativeBufferPtr();
cbPtrs.Add(rt, ptr);
return(ptr);
}
}
public static unsafe void CopyFromUnsafe <T>(this ComputeBuffer dst, ref ComponentDataArray <T> src, int length) where T : struct, IComponentData
{
var stride = dst.stride;
var ptr = dst.GetNativeBufferPtr();
NativeArray <T> chunkArray;
for (int copiedCount = 0, chunkLength = 0; copiedCount < length; copiedCount += chunkLength)
{
chunkArray = src.GetChunkArray(copiedCount, length - copiedCount);
chunkLength = chunkArray.Length;
UnsafeUtility.MemCpy(ptr.ToPointer(), NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(chunkArray), chunkLength * stride);
ptr += chunkLength * stride;
}
}
public IntPtr GetShadowParamsPointer()
{
if (m_ShadowParamsCB == null)
{
return(IntPtr.Zero);
}
if (shadowParamsPointer == IntPtr.Zero)
{
shadowParamsPointer = m_ShadowParamsCB.GetNativeBufferPtr();
}
return(shadowParamsPointer);
}
public static int GetNativeBufferPtr(IntPtr l)
{
int result;
try
{
ComputeBuffer computeBuffer = (ComputeBuffer)LuaObject.checkSelf(l);
IntPtr nativeBufferPtr = computeBuffer.GetNativeBufferPtr();
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, nativeBufferPtr);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
private void Update()
{
if (transform.hasChanged)
{
_currentSample = 1;
transform.hasChanged = false;
}
if (Input.GetKeyDown(KeyCode.L))
{
Roughness *= 2;
}
else if (Input.GetKeyDown(KeyCode.K))
{
Roughness /= 2;
}
System.IntPtr ptr = buffer.GetNativeBufferPtr();
Debug.Log(ptr);
}
unsafe public ReadbackBuffer(ComputeBuffer source)
{
_source = source;
_readBuffer = new NativeArray <int>(source.count + 1, Allocator.Persistent);
_copyArgs = GCHandle.Alloc(
new CopyBufferEventArgs {
source = source.GetNativeBufferPtr(),
destination = (IntPtr)_readBuffer.GetUnsafePtr(),
lengthInBytes = source.count * 4
},
GCHandleType.Pinned
);
_copyCommand = new CommandBuffer();
_copyCommand.IssuePluginEventAndData(
CopyBuffer_GetCallback(),
0, _copyArgs.AddrOfPinnedObject()
);
}
void AppendBufferTest()
{
shader = (ComputeShader)Resources.Load("shaders/ChunkCompute");
ComputeBuffer argBuffer = new ComputeBuffer(4, sizeof(int), ComputeBufferType.IndirectArguments);
int[] args = new int[] { 0, 1, 0, 0 };
argBuffer.SetData(args);
Min_Max = new ComputeBuffer(1, sizeof(float) * 2);
Data = new ComputeBuffer(18688, sizeof(float) + sizeof(uint), ComputeBufferType.Append);
Raw = new ComputeBuffer(18688, sizeof(float) + sizeof(uint));
Data.SetCounterValue(0);
int k = shader.FindKernel("CSMain");
shader.SetBuffer(k, "Min_Max", Min_Max);
shader.SetBuffer(k, "Data", Data);
shader.SetBuffer(k, "Raw", Raw);
Stopwatch watch = new Stopwatch();
watch.Start();
shader.Dispatch(k, 18688 / 16, 1, 1);
Vector2[] min_max = new Vector2[1];
Min_Max.GetData(min_max);
Min_Max.GetNativeBufferPtr();
ComputeBuffer.CopyCount(Data, argBuffer, 0);
argBuffer.GetData(args);
watch.Stop();
Debug.LogFormat("Get Metadata: {0}: {1} - {2}", watch.Elapsed, min_max[0].x, min_max[0].y);
Debug.Log("count: " + args[0]);
Debug.Log("instance count: " + args[1]);
Debug.Log("start count: " + args[2]);
Debug.Log("start instance: " + args[3]);
watch.Restart();
Result[] data = new Result[args[0]];
Data.GetData(data);
watch.Stop();
Debug.LogFormat("Get Data: {0}: {1}", watch.Elapsed, Mathf.Max(0, 0));
}
public static UniversalAsyncGPUReadbackRequest Request(ComputeBuffer computeBuffer)
{
if (SystemInfo.supportsAsyncGPUReadback)
{
return(new UniversalAsyncGPUReadbackRequest()
{
isPlugin = false,
uInited = true,
uDisposd = false,
uRequest = AsyncGPUReadback.Request(computeBuffer),
});
}
else
{
return(new UniversalAsyncGPUReadbackRequest()
{
isPlugin = true,
oRequest = OpenGLAsyncReadbackRequest.CreateComputeBufferRequest((int)computeBuffer.GetNativeBufferPtr(), computeBuffer.stride * computeBuffer.count),
});
}
}
private bool BindBufferToTensor(int tensorIndex, ComputeBuffer buffer)
{
Debug.Assert(buffer.IsValid());
Debug.Assert(Delegate != TfLiteDelegate.Zero);
return(TFLGpuDelegateBindMetalBufferToTensor(Delegate, tensorIndex, buffer.GetNativeBufferPtr()));
}
