// as well as passing various numbers of them (so that we exceed the available registers),
// and mixing the HVA parameters with non-HVA parameters.
-// This is a skeleton version. Remaining to do:
-// - Add more HVA types: using Vector64 and with varying numbers of vectors.
+// This Test case covers all cases for
+// Methods that take one HVA argument with between 1 and 9 Vectror64 or Vector128 elements
+// - Called normally or by using reflection
+// Methods that return an HVA with between 1 and 9 Vectror64 or Vector128 elements
+// - Called normally or by using reflection
+
+// Remaining Test cases to do:
+// - Add tests that have one than one HVA argument
// - Add types that are *not* HVA types (e.g. too many vectors, or using Vector256).
-// - Add diagnostic info so that it is easier to see what has failed.
+// - Add tests that use a mix of HVA and non-HVA arguments
public static class VectorMgdMgd
{
public unsafe class HVATests<T> where T : struct
{
- // We can have up to 4 vectors in an HVA, and we'll test structs with up to 6 (3x2) of them
+ // An HVA can contain up to 4 vectors, so we'll test structs with up to 5 of them
// (to ensure that even those that are too large are handled consistently).
- // So we need 6 * the element count in the largest (128-bit) vector with the smallest
+ // So we need 5 * the element count in the largest (128-bit) vector with the smallest
// element type (byte).
static T[] values;
static T[] check;
- private int ElementCount = (Unsafe.SizeOf<Vector128<T>>() / sizeof(byte)) * 6;
+ private int ElementCount = (Unsafe.SizeOf<Vector128<T>>() / sizeof(byte)) * 5;
public bool isPassing = true;
public bool isReflection = false;
public Vector128<T> v2;
}
+ public struct HVA128_04
+ {
+ public Vector128<T> v0;
+ public Vector128<T> v1;
+ public Vector128<T> v2;
+ public Vector128<T> v3;
+ }
+
+ public struct HVA128_05
+ {
+ public Vector128<T> v0;
+ public Vector128<T> v1;
+ public Vector128<T> v2;
+ public Vector128<T> v3;
+ public Vector128<T> v4;
+ }
+
private HVA128_01 hva128_01;
private HVA128_02 hva128_02;
private HVA128_03 hva128_03;
+ private HVA128_04 hva128_04;
+ private HVA128_05 hva128_05;
////////////////////////////////////////
hva128_03.v1 = Unsafe.As<T, Vector128<T>>(ref values[i]);
i += Vector128<T>.Count;
hva128_03.v2 = Unsafe.As<T, Vector128<T>>(ref values[i]);
- }
+
+ i = 0;
+ hva128_04.v0 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ i += Vector128<T>.Count;
+ hva128_04.v1 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ i += Vector128<T>.Count;
+ hva128_04.v2 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ i += Vector128<T>.Count;
+ hva128_04.v3 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+
+ i = 0;
+ hva128_05.v0 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ i += Vector128<T>.Count;
+ hva128_05.v1 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ i += Vector128<T>.Count;
+ hva128_05.v2 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ i += Vector128<T>.Count;
+ hva128_05.v3 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ i += Vector128<T>.Count;
+ hva128_05.v4 = Unsafe.As<T, Vector128<T>>(ref values[i]);
+ }
public HVATests()
{
reflectionInvokeArgs = new object[] { hva64_05 };
}
- //=============== Tests for return values if HFA64
+ //=============== Tests for return values if HVA64
//==================== Tests for return values of HVA64_01
return hva64_01;
}
- public void testReturn_HFA64_01()
+ public void testReturn_HVA64_01()
{
HVA64_01 result = returnTest_HVA64_01();
checkValues("testReturn_HVA64_01(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA64_01()
+ public void testReflectionReturn_HVA64_01()
{
Init_Reflection_Return_HVA64_01();
return hva64_02;
}
- public void testReturn_HFA64_02()
+ public void testReturn_HVA64_02()
{
HVA64_02 result = returnTest_HVA64_02();
checkValues("testReturn_HVA64_02(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA64_02()
+ public void testReflectionReturn_HVA64_02()
{
Init_Reflection_Return_HVA64_02();
return hva64_03;
}
- public void testReturn_HFA64_03()
+ public void testReturn_HVA64_03()
{
HVA64_03 result = returnTest_HVA64_03();
checkValues("testReturn_HVA64_03(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA64_03()
+ public void testReflectionReturn_HVA64_03()
{
Init_Reflection_Return_HVA64_03();
return hva64_04;
}
- public void testReturn_HFA64_04()
+ public void testReturn_HVA64_04()
{
HVA64_04 result = returnTest_HVA64_04();
checkValues("testReturn_HVA64_04(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA64_04()
+ public void testReflectionReturn_HVA64_04()
{
Init_Reflection_Return_HVA64_04();
return hva64_05;
}
- public void testReturn_HFA64_05()
+ public void testReturn_HVA64_05()
{
HVA64_05 result = returnTest_HVA64_05();
checkValues("testReturn_HVA64_05(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA64_05()
+ public void testReflectionReturn_HVA64_05()
{
Init_Reflection_Return_HVA64_05();
reflectionInvokeArgs = new object[] { hva128_03 };
}
+ //==================== Tests for passing 1 argumnet of HVA128_04
+
+ // Test the case where we've passed in a single argument HVA of 2 vectors.
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public void test1Argument_HVA128_04(HVA128_04 arg1)
+ {
+ checkValues("test1Argument_HVA128_04(arg1.v0)", arg1.v0, 0);
+ checkValues("test1Argument_HVA128_04(arg1.v1)", arg1.v1, 1 * Vector128<T>.Count);
+ checkValues("test1Argument_HVA128_04(arg1.v2)", arg1.v2, 2 * Vector128<T>.Count);
+ checkValues("test1Argument_HVA128_04(arg1.v3)", arg1.v3, 3 * Vector128<T>.Count);
+ }
+
+ public void Init_Reflection_Args_HVA128_04()
+ {
+ isReflection = true;
+ reflectionParameterTypes = new Type[] { typeof(HVA128_04) };
+ reflectionMethodInfo = typeof(HVATests<T>).GetMethod(nameof(HVATests<T>.test1Argument_HVA128_04), reflectionParameterTypes);
+ reflectionInvokeArgs = new object[] { hva128_04 };
+ }
+
+ //==================== Tests for passing 1 argumnet of HVA128_05
+
+ // Test the case where we've passed in a single argument HVA of 2 vectors.
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public void test1Argument_HVA128_05(HVA128_05 arg1)
+ {
+ checkValues("test1Argument_HVA128_05(arg1.v0)", arg1.v0, 0);
+ checkValues("test1Argument_HVA128_05(arg1.v1)", arg1.v1, 1 * Vector128<T>.Count);
+ checkValues("test1Argument_HVA128_05(arg1.v2)", arg1.v2, 2 * Vector128<T>.Count);
+ checkValues("test1Argument_HVA128_05(arg1.v3)", arg1.v3, 3 * Vector128<T>.Count);
+ checkValues("test1Argument_HVA128_05(arg1.v4)", arg1.v4, 4 * Vector128<T>.Count);
+ }
+
+ public void Init_Reflection_Args_HVA128_05()
+ {
+ isReflection = true;
+ reflectionParameterTypes = new Type[] { typeof(HVA128_05) };
+ reflectionMethodInfo = typeof(HVATests<T>).GetMethod(nameof(HVATests<T>.test1Argument_HVA128_05), reflectionParameterTypes);
+ reflectionInvokeArgs = new object[] { hva128_05 };
+ }
+
//==================== Tests for return values of HVA128_01
// Return an HVA of 1 vector, with values from the 'values' array.
return hva128_01;
}
- public void testReturn_HFA128_01()
+ public void testReturn_HVA128_01()
{
HVA128_01 result = returnTest_HVA128_01();
checkValues("testReturn_HVA128_01(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA128_01()
+ public void testReflectionReturn_HVA128_01()
{
Init_Reflection_Return_HVA128_01();
return hva128_02;
}
- public void testReturn_HFA128_02()
+ public void testReturn_HVA128_02()
{
HVA128_02 result = returnTest_HVA128_02();
checkValues("testReturn_HVA128_02(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA128_02()
+ public void testReflectionReturn_HVA128_02()
{
Init_Reflection_Return_HVA128_02();
return hva128_03;
}
- public void testReturn_HFA128_03()
+ public void testReturn_HVA128_03()
{
HVA128_03 result = returnTest_HVA128_03();
checkValues("testReturn_HVA128_03(result.v0)",result.v0, 0);
reflectionInvokeArgs = new object[] { };
}
- public void testReflectionReturn_HFA128_03()
+ public void testReflectionReturn_HVA128_03()
{
Init_Reflection_Return_HVA128_03();
Done_Reflection();
}
+ //==================== Tests for return values of HVA128_04
+
+ // Return an HVA of 3 vectors, with values from the 'values' array.
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public HVA128_04 returnTest_HVA128_04()
+ {
+ return hva128_04;
+ }
+
+ public void testReturn_HVA128_04()
+ {
+ HVA128_04 result = returnTest_HVA128_04();
+ checkValues("testReturn_HVA128_04(result.v0)",result.v0, 0);
+ checkValues("testReturn_HVA128_04(result.v1)",result.v1, 1 * Vector128<T>.Count);
+ checkValues("testReturn_HVA128_04(result.v2)",result.v2, 2 * Vector128<T>.Count);
+ checkValues("testReturn_HVA128_04(result.v3)",result.v3, 3 * Vector128<T>.Count);
+ }
+
+ public void Init_Reflection_Return_HVA128_04()
+ {
+ isReflection = true;
+ reflectionParameterTypes = new Type[] { };
+ reflectionMethodInfo = typeof(HVATests<T>).GetMethod(nameof(HVATests<T>.returnTest_HVA128_04), reflectionParameterTypes);
+ reflectionInvokeArgs = new object[] { };
+ }
+
+ public void testReflectionReturn_HVA128_04()
+ {
+ Init_Reflection_Return_HVA128_04();
+
+ object objResult = reflectionMethodInfo.Invoke(this, reflectionInvokeArgs);
+
+ HVA128_04 result = (HVA128_04)objResult;
+
+ checkValues("testReflectionReturn_HVA128_04(result.v0)",result.v0, 0);
+ checkValues("testReflectionReturn_HVA128_04(result.v1)",result.v1, 1 * Vector128<T>.Count);
+ checkValues("testReflectionReturn_HVA128_04(result.v2)",result.v2, 2 * Vector128<T>.Count);
+ checkValues("testReflectionReturn_HVA128_04(result.v3)",result.v3, 3 * Vector128<T>.Count);
+
+ Done_Reflection();
+ }
+
+ //==================== Tests for return values of HVA128_05
+
+ // Return an HVA of 3 vectors, with values from the 'values' array.
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public HVA128_05 returnTest_HVA128_05()
+ {
+ return hva128_05;
+ }
+
+ public void testReturn_HVA128_05()
+ {
+ HVA128_05 result = returnTest_HVA128_05();
+ checkValues("testReturn_HVA128_05(result.v0)",result.v0, 0);
+ checkValues("testReturn_HVA128_05(result.v1)",result.v1, 1 * Vector128<T>.Count);
+ checkValues("testReturn_HVA128_05(result.v2)",result.v2, 2 * Vector128<T>.Count);
+ checkValues("testReturn_HVA128_05(result.v3)",result.v3, 3 * Vector128<T>.Count);
+ checkValues("testReturn_HVA128_05(result.v4)",result.v4, 4 * Vector128<T>.Count);
+ }
+
+ public void Init_Reflection_Return_HVA128_05()
+ {
+ isReflection = true;
+ reflectionParameterTypes = new Type[] { };
+ reflectionMethodInfo = typeof(HVATests<T>).GetMethod(nameof(HVATests<T>.returnTest_HVA128_05), reflectionParameterTypes);
+ reflectionInvokeArgs = new object[] { };
+ }
+
+ public void testReflectionReturn_HVA128_05()
+ {
+ Init_Reflection_Return_HVA128_05();
+
+ object objResult = reflectionMethodInfo.Invoke(this, reflectionInvokeArgs);
+
+ HVA128_05 result = (HVA128_05)objResult;
+
+ checkValues("testReflectionReturn_HVA128_05(result.v0)",result.v0, 0);
+ checkValues("testReflectionReturn_HVA128_05(result.v1)",result.v1, 1 * Vector128<T>.Count);
+ checkValues("testReflectionReturn_HVA128_05(result.v2)",result.v2, 2 * Vector128<T>.Count);
+ checkValues("testReflectionReturn_HVA128_05(result.v3)",result.v3, 3 * Vector128<T>.Count);
+ checkValues("testReflectionReturn_HVA128_05(result.v4)",result.v4, 4 * Vector128<T>.Count);
+
+ Done_Reflection();
+ }
+
//////////////////////////////////////////////////
public void doTests()
// Test HVA Vector64<T> Return values
- testReturn_HFA64_01();
+ testReturn_HVA64_01();
- testReflectionReturn_HFA64_01();
+ testReflectionReturn_HVA64_01();
- testReturn_HFA64_02();
+ testReturn_HVA64_02();
- testReflectionReturn_HFA64_02();
+ testReflectionReturn_HVA64_02();
- testReturn_HFA64_03();
+ testReturn_HVA64_03();
- testReflectionReturn_HFA64_03();
+ testReflectionReturn_HVA64_03();
- testReturn_HFA64_04();
+ testReturn_HVA64_04();
- testReflectionReturn_HFA64_04();
+ testReflectionReturn_HVA64_04();
- testReturn_HFA64_05();
+ testReturn_HVA64_05();
- testReflectionReturn_HFA64_05();
+ testReflectionReturn_HVA64_05();
////// Vector128<T> tests
Done_Reflection();
- // Test HVA Vector128<T> Return values
+ test1Argument_HVA128_04(hva128_04);
+
+ Init_Reflection_Args_HVA128_04();
+ reflectionMethodInfo.Invoke(this, reflectionInvokeArgs);
+ Done_Reflection();
+
+
+ test1Argument_HVA128_05(hva128_05);
- testReturn_HFA128_01();
+ Init_Reflection_Args_HVA128_05();
+ reflectionMethodInfo.Invoke(this, reflectionInvokeArgs);
+ Done_Reflection();
- testReflectionReturn_HFA128_01();
+ // Test HVA Vector128<T> Return values
- testReturn_HFA128_02();
+ testReturn_HVA128_01();
+ testReflectionReturn_HVA128_01();
- testReflectionReturn_HFA128_02();
+ testReturn_HVA128_02();
+ testReflectionReturn_HVA128_02();
+ testReturn_HVA128_03();
+ testReflectionReturn_HVA128_03();
- testReturn_HFA128_03();
+ testReturn_HVA128_04();
+ testReflectionReturn_HVA128_04();
- testReflectionReturn_HFA128_03();
+ testReturn_HVA128_05();
+ testReflectionReturn_HVA128_05();
}
}
projects / platform / upstream / coreclr.git / commitdiff