public unsafe static void Main() { ExampleStruct ex = new ExampleStruct(); byte * addr = (byte *)&ex; Console.WriteLine("Size: {0}", sizeof(ExampleStruct)); Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr); Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr); Console.WriteLine("i3 Offset: {0}", (byte *)&ex.i3 - addr); }
public void BasicUploads() { if (!SystemInfo.supportsComputeShaders) { Assert.Ignore("Skipped due to platform/computer not supporting compute shaders"); return; } var initialData = new ExampleStruct[1024]; for (int i = 0; i < initialData.Length; ++i) { initialData[i] = new ExampleStruct { someData = i } } ; Setup(initialData); var structSize = UnsafeUtility.SizeOf <ExampleStruct>(); var totalSize = structSize * initialData.Length; var tsu = uploader.Begin(totalSize, totalSize, initialData.Length); tsu.AddUpload(new ExampleStruct { someData = 7 }, 4); uploader.EndAndCommit(tsu); var resultingData = new ExampleStruct[initialData.Length]; buffer.GetData(resultingData); Assert.AreEqual(0, resultingData[0].someData); Assert.AreEqual(7, resultingData[1].someData); Assert.AreEqual(2, resultingData[2].someData); tsu = uploader.Begin(structSize, structSize, 1); tsu.AddUpload(new ExampleStruct { someData = 13 }, 8); uploader.EndAndCommit(tsu); buffer.GetData(resultingData); Assert.AreEqual(0, resultingData[0].someData); Assert.AreEqual(7, resultingData[1].someData); Assert.AreEqual(13, resultingData[2].someData); Assert.AreEqual(3, resultingData[3].someData); Teardown(); }
public void SmallUpload() { if (!SystemInfo.supportsComputeShaders) { Assert.Ignore("Skipped due to platform/computer not supporting compute shaders"); return; } var initialData = new ExampleStruct[64]; for (int i = 0; i < initialData.Length; ++i) { initialData[i] = new ExampleStruct { someData = 0 }; } var buffer = new ComputeBuffer(initialData.Length, UnsafeUtility.SizeOf <ExampleStruct>()); buffer.SetData(initialData); var uploader = new SparseUploader(buffer); { var tsu = uploader.Begin(UnsafeUtility.SizeOf <ExampleStruct>() * initialData.Length, initialData.Length); for (int i = 0; i < initialData.Length; ++i) { tsu.AddUpload(new ExampleStruct { someData = i }, i * 4); } uploader.EndAndCommit(tsu); } var resultingData = new ExampleStruct[initialData.Length]; buffer.GetData(resultingData); for (int i = 0; i < resultingData.Length; ++i) { Assert.AreEqual(i, resultingData[i].someData); } uploader.Dispose(); buffer.Dispose(); }
public void SmallUpload() { if (!SystemInfo.supportsComputeShaders) { Assert.Ignore("Skipped due to platform/computer not supporting compute shaders"); return; } var initialData = new ExampleStruct[64]; for (int i = 0; i < initialData.Length; ++i) { initialData[i] = new ExampleStruct { someData = 0 } } ; Setup(initialData); var structSize = UnsafeUtility.SizeOf <ExampleStruct>(); var totalSize = structSize * initialData.Length; var tsu = uploader.Begin(totalSize, structSize, initialData.Length); for (int i = 0; i < initialData.Length; ++i) { tsu.AddUpload(new ExampleStruct { someData = i }, i * 4); } uploader.EndAndCommit(tsu); var resultingData = new ExampleStruct[initialData.Length]; buffer.GetData(resultingData); for (int i = 0; i < resultingData.Length; ++i) { Assert.AreEqual(i, resultingData[i].someData); } Teardown(); }
public void UploadFromJobs() { if (!SystemInfo.supportsComputeShaders) { Assert.Ignore("Skipped due to platform/computer not supporting compute shaders"); return; } var initialData = new ExampleStruct[4 * 1024]; var stride = UnsafeUtility.SizeOf <ExampleStruct>(); for (int i = 0; i < initialData.Length; ++i) { initialData[i] = new ExampleStruct { someData = 0 }; } var buffer = new ComputeBuffer(initialData.Length, stride); buffer.SetData(initialData); var uploader = new SparseUploader(buffer); var job = new UploadJob(); job.uploader = uploader.Begin(initialData.Length * stride, initialData.Length); job.Schedule(initialData.Length, 64).Complete(); uploader.EndAndCommit(job.uploader); var resultingData = new ExampleStruct[initialData.Length]; buffer.GetData(resultingData); for (int i = 0; i < resultingData.Length; ++i) { Assert.AreEqual(i, resultingData[i].someData); } uploader.Dispose(); buffer.Dispose(); }
public void ToNativeStruct_Returns_Correct_Values_In_Custom_Struct() { XmlRpcStruct str = new XmlRpcStruct(new Struct() { { "Field1", new XmlRpcInteger(3425) }, { "Field2", new XmlRpcDouble(325.235) }, { "Field3", new XmlRpcString("Test String") }, { "Field4", new XmlRpcBoolean(true) }, { "Field5", new XmlRpcBoolean(false) }, { "Field6", new XmlRpcBase64(Base64.FromBase64String("VGVzdCBTdHJpbmc=")) }, { "Field7", new XmlRpcDateTime(DateTime.Parse("2021-04-06T16:36:44.1557489+02:00").ToUniversalTime()) }, { "Field8", new XmlRpcArray(new XmlRpcBaseType[] { new XmlRpcInteger(1), new XmlRpcInteger(2), new XmlRpcInteger(3) }) }, { "Field9", new XmlRpcStruct(new Struct() { { "Field1", new XmlRpcInteger(1) }, { "Field2", new XmlRpcInteger(2) }, { "Field3", new XmlRpcInteger(3) } }) }, }); ExampleStruct result = (ExampleStruct)XmlRpcTypes.ToNativeStruct <ExampleStruct>(str); Base64 field6Expected = Base64.FromBase64String("VGVzdCBTdHJpbmc="); DateTime field7Expected = DateTime.Parse("2021-04-06T16:36:44.1557489+02:00").ToUniversalTime(); Assert.NotNull(result); Assert.Equal(3425, result.Field1); Assert.Equal(325.235, result.Field2); Assert.Equal("Test String", result.Field3); Assert.True(result.Field4); Assert.False(result.Field5); Assert.Equal(field6Expected, result.Field6); Assert.Equal(field7Expected, result.Field7); Assert.Equal(new int[] { 1, 2, 3 }, result.Field8); Assert.NotNull(result.Field9); Assert.Equal(1, result.Field9.Field1); Assert.Equal(2, result.Field9.Field2); Assert.Equal(3, result.Field9.Field3); }
public void ClassGetDefault() { object result; object expect; result = Energy.Base.Class.GetDefault(typeof(DateTime)); expect = DateTime.MinValue; Assert.AreEqual(expect, result); result = Energy.Base.Class.GetDefault <DateTime>(); Assert.AreEqual(expect, result); result = Energy.Base.Class.GetDefault(typeof(ExampleStruct)); expect = new ExampleStruct() { Value = null }; Assert.AreEqual(expect, result); result = Energy.Base.Class.GetDefault <ExampleStruct>(); Assert.AreEqual(expect, result); }
public void RewriteConstructor() { var info = typeof(ExampleClass).GetConstructor(new[] { typeof(int) }); var context = new ShimContext(); var rewrite = ILRewriter.ILRewriter.Rewrite(info, context); var exampleClass = new ExampleClass(2); rewrite.Invoke(null, new object[] { exampleClass, 3, context }); Assert.Equal(3, exampleClass.Factor); info = typeof(ExampleStruct).GetConstructor(new[] { typeof(int) }); rewrite = ILRewriter.ILRewriter.Rewrite(info, new ShimContext()); var dele = (ExampleStructConstructor)rewrite.CreateDelegate(typeof(ExampleStructConstructor)); var exampleStruct = new ExampleStruct(2); dele(ref exampleStruct, 3, context); Assert.Equal(3, exampleStruct.Factor); }
public void ReplaceBuffer() { if (!SystemInfo.supportsComputeShaders) { Assert.Ignore("Skipped due to platform/computer not supporting compute shaders"); return; } var initialData = new ExampleStruct[64]; for (int i = 0; i < initialData.Length; ++i) { initialData[i] = new ExampleStruct { someData = i } } ; Setup(initialData); var newBuffer = new ComputeBuffer(initialData.Length * 2, UnsafeUtility.SizeOf <ExampleStruct>()); uploader.ReplaceBuffer(newBuffer, true); buffer.Dispose(); buffer = newBuffer; var resultingData = new ExampleStruct[initialData.Length]; buffer.GetData(resultingData); for (int i = 0; i < resultingData.Length; ++i) { Assert.AreEqual(i, resultingData[i].someData); } Teardown(); }
public unsafe void BigUploads() { if (!SystemInfo.supportsComputeShaders) { Assert.Ignore("Skipped due to platform/computer not supporting compute shaders"); return; } var initialData = new ExampleStruct[4 * 1024]; for (int i = 0; i < initialData.Length; ++i) { initialData[i] = new ExampleStruct { someData = i } } ; Setup(initialData); var newData = new ExampleStruct[312]; for (int i = 0; i < newData.Length; ++i) { newData[i] = new ExampleStruct { someData = i + 3000 } } ; var newData2 = new ExampleStruct[316]; for (int i = 0; i < newData2.Length; ++i) { newData2[i] = new ExampleStruct { someData = i + 4000 } } ; var structSize = UnsafeUtility.SizeOf <ExampleStruct>(); var totalSize = structSize * (newData.Length + newData2.Length); var tsu = uploader.Begin(totalSize, totalSize, initialData.Length); fixed(void *ptr = newData) tsu.AddUpload(ptr, newData.Length * 4, 512 * 4); fixed(void *ptr2 = newData2) tsu.AddUpload(ptr2, newData2.Length * 4, 1136 * 4); uploader.EndAndCommit(tsu); var resultingData = new ExampleStruct[initialData.Length]; buffer.GetData(resultingData); for (int i = 0; i < resultingData.Length; ++i) { if (i < 512) { Assert.AreEqual(i, resultingData[i].someData); } else if (i < 824) { Assert.AreEqual(i - 512 + 3000, resultingData[i].someData); } else if (i < 1136) { Assert.AreEqual(i, resultingData[i].someData); } else if (i < 1452) { Assert.AreEqual(i - 1136 + 4000, resultingData[i].someData); } else { Assert.AreEqual(i, resultingData[i].someData); } } Teardown(); }
private static extern int AcceptStruct(ref ExampleStruct s);
// Test functions private void Awake() { // return int print(ReturnInt()); // accept string bool r1 = AcceptStr("BAR"); bool r2 = AcceptStr("FOO"); print("r1=" + r1); print("r2=" + r2); // accept byte array, uses marshalling to pass array back and forth byte[] arr1 = { 0, 0, 0 }; AcceptArray1(arr1, arr1.Length); for (int i = 0; i < arr1.Length; i++) { print("arr" + i + "=" + arr1[i]); } // accept byte array, passes no-copy raw memory pointer byte[] arr2 = { 0, 0, 0 }; GCHandle h = GCHandle.Alloc(arr2, GCHandleType.Pinned); AcceptArray2(h.AddrOfPinnedObject(), arr2.Length); for (int i = 0; i < arr2.Length; i++) { print("arr" + i + "=" + arr2[i]); } h.Free(); // return dynamically allocated string string s1 = ReturnDynamicStr(); print("s1=" + s1); // return constant string string s2 = Marshal.PtrToStringAnsi(ReturnConstStr()); print("s2=" + s2); // return dynamically allocated byte array int arraySize = 0; IntPtr dataPtr = ReturnDynamicByteArray(ref arraySize); byte[] data = new byte[arraySize]; Marshal.Copy(dataPtr, data, 0, arraySize); Marshal.FreeCoTaskMem(dataPtr); // deallocate unmanaged memory print("data[" + arraySize + "] = [" + data[0] + ", " + data[1] + ", " + data[2] + ",...]"); // return dynamically allocated string array arraySize = 0; dataPtr = ReturnDynamicStrArray(ref arraySize); String[] strArray = MarshalStringArray(dataPtr, arraySize); print("strArray[" + arraySize + "] = [" + String.Join(",", strArray) + "]"); // string array as parameter dataPtr = MarshalStringArray(new String[] { "foo1", "foo2", "foo3" }); int len = AcceptStrArray(dataPtr, arraySize); print("len=" + len); CleanUpNativeStrArray(dataPtr, arraySize); //strArray = MarshalStringArray(dataPtr, 3); // Structure as parameter ExampleStruct s = new ExampleStruct { val1 = 9999, array1 = new UInt32[3], array2 = new UInt32[10] }; s.array1[0] = 1; s.array1[1] = 2; s.array1[2] = 3; s.array2len = 5; s.array2[0] = 10; s.array2[1] = 11; s.array2[2] = 12; s.array2[3] = 13; s.array2[4] = 14; s.str1 = "Cat is a feline"; len = AcceptStruct(ref s); print("s.val1=" + s.val1 + " len=" + len); // return struct ExamplePoint p = ReturnStruct(); // Marshal array of point objects arraySize = 0; dataPtr = ReturnArrayOfPoints(ref arraySize); ExamplePoint[] pointArr = new ExamplePoint[arraySize]; // memory layout // |float|float|float|float|float|float|float|float|float|float.. // | ExamplePoint0 | ExamplePoint1 | ExamplePoint2 | int offset = 0; int pointSize = Marshal.SizeOf(typeof(ExamplePoint)); for (int i = 0; i < arraySize; i++) { pointArr[i] = (ExamplePoint)Marshal.PtrToStructure(new IntPtr(dataPtr.ToInt32() + offset), typeof(ExamplePoint)); offset += pointSize; } print("pointArr[" + arraySize + "]=[" + pointArr[0] + ", " + pointArr[1] + ",...]"); Marshal.FreeCoTaskMem(dataPtr); print("Done!"); }
public void BigUploads() { if (!SystemInfo.supportsComputeShaders) { Assert.Ignore("Skipped due to platform/computer not supporting compute shaders"); return; } var initialData = new ExampleStruct[4 * 1024]; for (int i = 0; i < initialData.Length; ++i) { initialData[i] = new ExampleStruct { someData = i }; } var buffer = new ComputeBuffer(initialData.Length, UnsafeUtility.SizeOf <ExampleStruct>()); buffer.SetData(initialData); var uploader = new SparseUploader(buffer); var newData = new ExampleStruct[312]; for (int i = 0; i < newData.Length; ++i) { newData[i] = new ExampleStruct { someData = i + 3000 }; } var newData2 = new ExampleStruct[316]; for (int i = 0; i < newData2.Length; ++i) { newData2[i] = new ExampleStruct { someData = i + 4000 }; } var tsu = uploader.Begin(UnsafeUtility.SizeOf <ExampleStruct>() * (newData.Length + newData2.Length), 2); unsafe { fixed(void *ptr = newData) { tsu.AddUpload(ptr, newData.Length * 4, 512 * 4); } fixed(void *ptr2 = newData2) { tsu.AddUpload(ptr2, newData2.Length * 4, 1136 * 4); } } uploader.EndAndCommit(tsu); var resultingData = new ExampleStruct[initialData.Length]; buffer.GetData(resultingData); for (int i = 0; i < resultingData.Length; ++i) { if (i < 512) { Assert.AreEqual(i, resultingData[i].someData); } else if (i < 824) { Assert.AreEqual(i - 512 + 3000, resultingData[i].someData); } else if (i < 1136) { Assert.AreEqual(i, resultingData[i].someData); } else if (i < 1452) { Assert.AreEqual(i - 1136 + 4000, resultingData[i].someData); } else { Assert.AreEqual(i, resultingData[i].someData); } } uploader.Dispose(); buffer.Dispose(); }