forked from BilalY/Rasagar
290 lines
11 KiB
C#
290 lines
11 KiB
C#
using System.Collections;
|
|
using NUnit.Framework;
|
|
using Unity.Burst;
|
|
using UnityEngine;
|
|
using Unity.Jobs.LowLevel.Unsafe;
|
|
using UnityEngine.TestTools;
|
|
using System;
|
|
using Unity.Jobs;
|
|
|
|
[TestFixture]
|
|
public class PlaymodeTest
|
|
{
|
|
// [UnityTest]
|
|
public IEnumerator CheckBurstJobEnabledDisabled()
|
|
{
|
|
BurstCompiler.Options.EnableBurstCompileSynchronously = true;
|
|
foreach(var item in CheckBurstJobDisabled()) yield return item;
|
|
foreach(var item in CheckBurstJobEnabled()) yield return item;
|
|
}
|
|
|
|
private IEnumerable CheckBurstJobEnabled()
|
|
{
|
|
BurstCompiler.Options.EnableBurstCompilation = true;
|
|
|
|
yield return null;
|
|
|
|
using (var jobTester = new BurstJobTester2())
|
|
{
|
|
var result = jobTester.Calculate();
|
|
Assert.AreNotEqual(0.0f, result);
|
|
}
|
|
}
|
|
|
|
private IEnumerable CheckBurstJobDisabled()
|
|
{
|
|
BurstCompiler.Options.EnableBurstCompilation = false;
|
|
|
|
yield return null;
|
|
|
|
using (var jobTester = new BurstJobTester2())
|
|
{
|
|
var result = jobTester.Calculate();
|
|
Assert.AreEqual(0.0f, result);
|
|
}
|
|
}
|
|
|
|
|
|
[BurstCompile(CompileSynchronously = true)]
|
|
private struct ThrowingJob : IJob
|
|
{
|
|
public int I;
|
|
|
|
public void Execute()
|
|
{
|
|
if (I < 0)
|
|
{
|
|
throw new System.Exception("Some Exception!");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void NoSafetyCheckExceptionWarningInEditor()
|
|
{
|
|
var job = new ThrowingJob { I = 42 };
|
|
job.Schedule().Complete();
|
|
|
|
// UNITY_BURST_DEBUG enables additional logging which messes with our check.
|
|
var debuggingStr = Environment.GetEnvironmentVariable("UNITY_BURST_DEBUG");
|
|
if (debuggingStr == null || !int.TryParse(debuggingStr, out var debugLevel) || debugLevel == 0)
|
|
{
|
|
LogAssert.NoUnexpectedReceived();
|
|
}
|
|
}
|
|
|
|
private struct MyKey { public struct MySubKey0 { } public struct MySubKey1 { } }
|
|
private struct SomeGenericStruct<T> {}
|
|
|
|
private static readonly SharedStatic<int> SharedStaticOneType = SharedStatic<int>.GetOrCreate<MyKey>();
|
|
private static readonly SharedStatic<double> SharedStaticTwoTypes0 = SharedStatic<double>.GetOrCreate<MyKey, MyKey.MySubKey0>();
|
|
private static readonly SharedStatic<double> SharedStaticTwoTypes1 = SharedStatic<double>.GetOrCreate<MyKey, MyKey.MySubKey1>();
|
|
|
|
private struct MyGenericContainingStruct<T>
|
|
{
|
|
public static readonly SharedStatic<int> Data0 = SharedStatic<int>.GetOrCreate<T>();
|
|
public static readonly SharedStatic<int> Data1 = SharedStatic<int>.GetOrCreate<SomeGenericStruct<MyKey>, T>();
|
|
public static readonly SharedStatic<int> Data2 = SharedStatic<int>.GetOrCreate<SomeGenericStruct<T>, MyKey>();
|
|
}
|
|
|
|
private static readonly SharedStatic<int> SharedStaticWithSystemTypes0 = SharedStatic<int>.GetOrCreate<IntPtr>();
|
|
private static readonly SharedStatic<int> SharedStaticWithSystemTypes1 = SharedStatic<int>.GetOrCreate<IntPtr, MyKey>();
|
|
private static readonly SharedStatic<int> SharedStaticWithSystemTypes2 = SharedStatic<int>.GetOrCreate<MyKey, IntPtr>();
|
|
private static readonly SharedStatic<int> SharedStaticWithSystemTypes3 = SharedStatic<int>.GetOrCreate<IntPtr, IntPtr>();
|
|
|
|
[Test]
|
|
public unsafe void SharedStaticPostProcessedTests()
|
|
{
|
|
var oneType = SharedStatic<int>.GetOrCreate(typeof(MyKey));
|
|
Assert.AreEqual((IntPtr)oneType.UnsafeDataPointer, (IntPtr)SharedStaticOneType.UnsafeDataPointer);
|
|
Assert.AreNotEqual((IntPtr)oneType.UnsafeDataPointer, (IntPtr)SharedStaticTwoTypes0.UnsafeDataPointer);
|
|
Assert.AreNotEqual((IntPtr)oneType.UnsafeDataPointer, (IntPtr)SharedStaticTwoTypes1.UnsafeDataPointer);
|
|
|
|
var twoTypes0 = SharedStatic<double>.GetOrCreate(typeof(MyKey), typeof(MyKey.MySubKey0));
|
|
Assert.AreEqual((IntPtr)twoTypes0.UnsafeDataPointer, (IntPtr)SharedStaticTwoTypes0.UnsafeDataPointer);
|
|
Assert.AreNotEqual((IntPtr)twoTypes0.UnsafeDataPointer, (IntPtr)SharedStaticOneType.UnsafeDataPointer);
|
|
Assert.AreNotEqual((IntPtr)twoTypes0.UnsafeDataPointer, (IntPtr)SharedStaticTwoTypes1.UnsafeDataPointer);
|
|
|
|
var twoTypes1 = SharedStatic<double>.GetOrCreate(typeof(MyKey), typeof(MyKey.MySubKey1));
|
|
Assert.AreEqual((IntPtr)twoTypes1.UnsafeDataPointer, (IntPtr)SharedStaticTwoTypes1.UnsafeDataPointer);
|
|
Assert.AreNotEqual((IntPtr)twoTypes1.UnsafeDataPointer, (IntPtr)SharedStaticOneType.UnsafeDataPointer);
|
|
Assert.AreNotEqual((IntPtr)twoTypes1.UnsafeDataPointer, (IntPtr)SharedStaticTwoTypes0.UnsafeDataPointer);
|
|
|
|
// A shared static in a generic struct, that uses the same type for `GetOrCreate`, will resolve to the same shared static.
|
|
Assert.AreEqual((IntPtr)oneType.UnsafeDataPointer, (IntPtr)MyGenericContainingStruct<MyKey>.Data0.UnsafeDataPointer);
|
|
|
|
// These two test partial evaluations of shared statics (where we can evaluate one of the template arguments at ILPP time
|
|
// but not both).
|
|
Assert.AreEqual(
|
|
(IntPtr)MyGenericContainingStruct<MyKey>.Data1.UnsafeDataPointer,
|
|
(IntPtr)MyGenericContainingStruct<MyKey>.Data2.UnsafeDataPointer);
|
|
|
|
// Check that system type evaluations all match up.
|
|
Assert.AreEqual(
|
|
(IntPtr)SharedStatic<int>.GetOrCreate(typeof(IntPtr)).UnsafeDataPointer,
|
|
(IntPtr)SharedStaticWithSystemTypes0.UnsafeDataPointer);
|
|
Assert.AreEqual(
|
|
(IntPtr)SharedStatic<int>.GetOrCreate(typeof(IntPtr), typeof(MyKey)).UnsafeDataPointer,
|
|
(IntPtr)SharedStaticWithSystemTypes1.UnsafeDataPointer);
|
|
Assert.AreEqual(
|
|
(IntPtr)SharedStatic<int>.GetOrCreate(typeof(MyKey), typeof(IntPtr)).UnsafeDataPointer,
|
|
(IntPtr)SharedStaticWithSystemTypes2.UnsafeDataPointer);
|
|
Assert.AreEqual(
|
|
(IntPtr)SharedStatic<int>.GetOrCreate(typeof(IntPtr), typeof(IntPtr)).UnsafeDataPointer,
|
|
(IntPtr)SharedStaticWithSystemTypes3.UnsafeDataPointer);
|
|
}
|
|
|
|
[BurstCompile]
|
|
public struct SomeFunctionPointers
|
|
{
|
|
[BurstDiscard]
|
|
private static void MessWith(ref int a) => a += 13;
|
|
|
|
[BurstCompile]
|
|
public static int A(int a, int b)
|
|
{
|
|
MessWith(ref a);
|
|
return a + b;
|
|
}
|
|
|
|
[BurstCompile(DisableDirectCall = true)]
|
|
public static int B(int a, int b)
|
|
{
|
|
MessWith(ref a);
|
|
return a - b;
|
|
}
|
|
|
|
[BurstCompile(CompileSynchronously = true)]
|
|
public static int C(int a, int b)
|
|
{
|
|
MessWith(ref a);
|
|
return a * b;
|
|
}
|
|
|
|
[BurstCompile(CompileSynchronously = true, DisableDirectCall = true)]
|
|
public static int D(int a, int b)
|
|
{
|
|
MessWith(ref a);
|
|
return a / b;
|
|
}
|
|
|
|
public delegate int Delegate(int a, int b);
|
|
}
|
|
|
|
[Test]
|
|
public void TestDirectCalls()
|
|
{
|
|
Assert.IsTrue(BurstCompiler.IsEnabled);
|
|
|
|
// a can either be (42 + 13) + 53 or 42 + 53 (depending on whether it was burst compiled).
|
|
var a = SomeFunctionPointers.A(42, 53);
|
|
Assert.IsTrue((a == ((42 + 13) + 53)) || (a == (42 + 53)));
|
|
|
|
// b can only be (42 + 13) - 53, because direct call is disabled and so we always call the managed method.
|
|
var b = SomeFunctionPointers.B(42, 53);
|
|
Assert.AreEqual((42 + 13) - 53, b);
|
|
|
|
// c can only be 42 * 53, because synchronous compilation is enabled.
|
|
var c = SomeFunctionPointers.C(42, 53);
|
|
Assert.AreEqual(42 * 53, c);
|
|
|
|
// d can only be (42 + 13) / 53, because even though synchronous compilation is enabled, direct call is disabled.
|
|
var d = SomeFunctionPointers.D(42, 53);
|
|
Assert.AreEqual((42 + 13) / 53, d);
|
|
}
|
|
|
|
[Test]
|
|
public void TestDirectCallInNamespacedClass()
|
|
{
|
|
void onCompileILPPMethod2()
|
|
{
|
|
Assert.Fail("BurstCompiler.CompileILPPMethod2 should not have been called at this time");
|
|
}
|
|
|
|
// We expect BurstCompiler.CompileILPPMethod2 to have been called at startup, via
|
|
// [InitializeOnLoad] or [RuntimeInitializeOnLoadMethod]. If it's called when we invoke
|
|
// N.C.A(), then something has gone wrong.
|
|
|
|
try
|
|
{
|
|
BurstCompiler.OnCompileILPPMethod2 += onCompileILPPMethod2;
|
|
|
|
var result = N.C.A();
|
|
Assert.AreEqual(42, result);
|
|
}
|
|
finally
|
|
{
|
|
BurstCompiler.OnCompileILPPMethod2 -= onCompileILPPMethod2;
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestFunctionPointers()
|
|
{
|
|
Assert.IsTrue(BurstCompiler.IsEnabled);
|
|
|
|
var A = BurstCompiler.CompileFunctionPointer<SomeFunctionPointers.Delegate>(SomeFunctionPointers.A);
|
|
var B = BurstCompiler.CompileFunctionPointer<SomeFunctionPointers.Delegate>(SomeFunctionPointers.B);
|
|
var C = BurstCompiler.CompileFunctionPointer<SomeFunctionPointers.Delegate>(SomeFunctionPointers.C);
|
|
var D = BurstCompiler.CompileFunctionPointer<SomeFunctionPointers.Delegate>(SomeFunctionPointers.D);
|
|
|
|
// a can either be (42 + 13) + 53 or 42 + 53 (depending on whether it was burst compiled).
|
|
var a = A.Invoke(42, 53);
|
|
Assert.IsTrue((a == ((42 + 13) + 53)) || (a == (42 + 53)));
|
|
|
|
// b can either be (42 + 13) - 53 or 42 - 53 (depending on whether it was burst compiled).
|
|
var b = B.Invoke(42, 53);
|
|
Assert.IsTrue((b == ((42 + 13) - 53)) || (b == (42 - 53)));
|
|
|
|
// c can only be 42 * 53, because synchronous compilation is enabled.
|
|
var c = C.Invoke(42, 53);
|
|
Assert.AreEqual(42 * 53, c);
|
|
|
|
// d can only be 42 / 53, because synchronous compilation is enabled.
|
|
var d = D.Invoke(42, 53);
|
|
Assert.AreEqual(42 / 53, d);
|
|
}
|
|
|
|
[BurstCompile]
|
|
public static class GenericClass<T>
|
|
{
|
|
[BurstCompile]
|
|
public static int ConcreteMethod() => 3;
|
|
}
|
|
|
|
public delegate int NoArgsIntReturnDelegate();
|
|
|
|
[Test]
|
|
public void TestGenericClassConcreteMethodFunctionPointer()
|
|
{
|
|
Assert.IsTrue(BurstCompiler.IsEnabled);
|
|
var F = BurstCompiler.CompileFunctionPointer<NoArgsIntReturnDelegate>(GenericClass<int>.ConcreteMethod);
|
|
Assert.AreEqual(3, F.Invoke());
|
|
}
|
|
}
|
|
|
|
// This test class is intentionally in a namespace to ensure that our
|
|
// direct-call [RuntimeInitializeOnLoadMethod] works correctly in that
|
|
// scenario.
|
|
namespace N
|
|
{
|
|
[BurstCompile]
|
|
internal static class C
|
|
{
|
|
public static int A() => B();
|
|
|
|
[BurstCompile(CompileSynchronously = true)]
|
|
private static int B()
|
|
{
|
|
var x = 42;
|
|
DiscardedMethod(ref x);
|
|
return x;
|
|
}
|
|
|
|
[BurstDiscard]
|
|
private static void DiscardedMethod(ref int x)
|
|
{
|
|
x += 1;
|
|
}
|
|
}
|
|
} |