diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/GenerateTests.csx b/src/tests/JIT/HardwareIntrinsics/General/Shared/GenerateTests.csx index 04e1cf8b2ee9a..84df601afdf6a 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Shared/GenerateTests.csx +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/GenerateTests.csx @@ -89,14 +89,14 @@ private static readonly (string templateFileName, Dictionary tem ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector64", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (uint)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector64", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (ulong)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToInt32", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (int)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToInt64", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (long)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToUInt32", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (uint)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToUInt64", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (ulong)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64())", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToInt32", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (int)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToInt64", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (long)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToUInt32", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (uint)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "ConvertToUInt64", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (ulong)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(firstOp[i])" }), ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "Create", ["VectorType"] = "Vector64", ["BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector64", ["Method"] = "Create", ["VectorType"] = "Vector64", ["BaseType"] = "Double", ["LargestVectorSize"] = "8", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), @@ -719,14 +719,14 @@ private static readonly (string templateFileName, Dictionary tem ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (uint)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (ulong)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToInt32", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (int)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToInt64", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (long)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToUInt32", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (uint)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToUInt64", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (ulong)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64())", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToInt32", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (int)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToInt64", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (long)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToUInt32", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (uint)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "ConvertToUInt64", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (ulong)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(firstOp[i])" }), ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "Create", ["VectorType"] = "Vector128", ["BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector128", ["Method"] = "Create", ["VectorType"] = "Vector128", ["BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), @@ -1402,14 +1402,14 @@ private static readonly (string templateFileName, Dictionary tem ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector256", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (uint)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (uint)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), ("VectorTernaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConditionalSelect", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector256", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (ulong)((secondOp[0] & firstOp[0]) | (thirdOp[0] & ~firstOp[0]))", ["ValidateRemainingResults"] = "result[i] != (ulong)((secondOp[i] & firstOp[i]) | (thirdOp[i] & ~firstOp[i]))" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToInt32", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (int)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToInt64", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (long)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToUInt32", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (uint)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(firstOp[i])" }), - ("VectorUnaryOpTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToUInt64", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (ulong)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToDouble", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64())", ["ValidateFirstResult"] = "result[0] != (double)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (double)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToInt32", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (int)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (int)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToInt64", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (long)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (long)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToSingle", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != (float)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (float)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToUInt32", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "result[0] != (uint)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (uint)(firstOp[i])" }), + ("VectorConvertToTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "ConvertToUInt64", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "result[0] != (ulong)(firstOp[0])", ["ValidateRemainingResults"] = "result[i] != (ulong)(firstOp[i])" }), ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "Create", ["VectorType"] = "Vector256", ["BaseType"] = "Byte", ["LargestVectorSize"] = "32", ["NextValueOp"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), ("VectorCreateTest.template", new Dictionary { ["Isa"] = "Vector256", ["Method"] = "Create", ["VectorType"] = "Vector256", ["BaseType"] = "Double", ["LargestVectorSize"] = "32", ["NextValueOp"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "resultElements[0] != expectedValue", ["ValidateRemainingResults"] = "resultElements[i] != expectedValue" }), @@ -2489,7 +2489,7 @@ private static void ProcessInput(StreamWriter testListFile, string groupName, (s testName = $"{input.templateData["Method"]}.{input.templateData["BaseType"]}"; testListFile.WriteLine($@" [""{testName}""] = {input.templateData["Method"]}{input.templateData["BaseType"]},"); } - else if (input.templateFileName == "VectorNarrowTest.template") + else if ((input.templateFileName == "VectorNarrowTest.template") || (input.templateFileName == "VectorConvertToTest.template")) { testName = $"{input.templateData["Method"]}.{input.templateData["Op1BaseType"]}"; testListFile.WriteLine($@" [""{testName}""] = {input.templateData["Method"]}{input.templateData["Op1BaseType"]},"); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorConvertToTest.template b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorConvertToTest.template new file mode 100644 index 0000000000000..ebb0731ab936b --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Shared/VectorConvertToTest.template @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +namespace JIT.HardwareIntrinsics.General +{ + public static partial class Program + { + private static void {Method}{Op1BaseType}() + { + var test = new VectorUnaryOpTest__{Method}{Op1BaseType}(); + + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + // Validates passing a static member works + test.RunClsVarScenario(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class VectorUnaryOpTest__{Method}{Op1BaseType} + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable({Op1BaseType}[] inArray1, {RetBaseType}[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); + if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(VectorUnaryOpTest__{Method}{Op1BaseType} testClass) + { + var result = {Isa}.{Method}(_fld1); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + + private static readonly int LargestVectorSize = {LargestVectorSize}; + + private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); + private static readonly int RetElementCount = Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>() / sizeof({RetBaseType}); + + private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; + + private static {Op1VectorType}<{Op1BaseType}> _clsVar1; + + private {Op1VectorType}<{Op1BaseType}> _fld1; + + private DataTable _dataTable; + + static VectorUnaryOpTest__{Method}{Op1BaseType}() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + } + + public VectorUnaryOpTest__{Method}{Op1BaseType}() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + _dataTable = new DataTable(_data1, new {RetBaseType}[RetElementCount], LargestVectorSize); + } + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = {Isa}.{Method}( + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { + typeof({Op1VectorType}<{Op1BaseType}>) + }); + + if (method is null) + { + method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), 1, new Type[] { + typeof({Op1VectorType}<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) + }); + } + + if (method.IsGenericMethodDefinition) + { + method = method.MakeGenericMethod(typeof({RetBaseType})); + } + + var result = method.Invoke(null, new object[] { + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = {Isa}.{Method}( + _clsVar1 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr); + var result = {Isa}.{Method}(op1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new VectorUnaryOpTest__{Method}{Op1BaseType}(); + var result = {Isa}.{Method}(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = {Isa}.{Method}(_fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + private void ValidateResult({Op1VectorType}<{Op1BaseType}> op1, void* result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + if ({ValidateFirstResult}) + { + succeeded = false; + } + else + { + for (var i = 1; i < RetElementCount; i++) + { + if ({ValidateRemainingResults}) + { + succeeded = false; + break; + } + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.Int64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.Int64.cs new file mode 100644 index 0000000000000..118a256259006 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.Int64.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +namespace JIT.HardwareIntrinsics.General +{ + public static partial class Program + { + private static void ConvertToDoubleInt64() + { + var test = new VectorUnaryOpTest__ConvertToDoubleInt64(); + + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + // Validates passing a static member works + test.RunClsVarScenario(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleInt64 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int64[] inArray1, Double[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleInt64 testClass) + { + var result = Vector128.ConvertToDouble(_fld1); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int64); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Double); + + private static Int64[] _data1 = new Int64[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static VectorUnaryOpTest__ConvertToDoubleInt64() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public VectorUnaryOpTest__ConvertToDoubleInt64() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + _dataTable = new DataTable(_data1, new Double[RetElementCount], LargestVectorSize); + } + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = Vector128.ConvertToDouble( + Unsafe.Read>(_dataTable.inArray1Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var method = typeof(Vector128).GetMethod(nameof(Vector128.ConvertToDouble), new Type[] { + typeof(Vector128) + }); + + if (method is null) + { + method = typeof(Vector128).GetMethod(nameof(Vector128.ConvertToDouble), 1, new Type[] { + typeof(Vector128<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) + }); + } + + if (method.IsGenericMethodDefinition) + { + method = method.MakeGenericMethod(typeof(Double)); + } + + var result = method.Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = Vector128.ConvertToDouble( + _clsVar1 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = Vector128.ConvertToDouble(op1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new VectorUnaryOpTest__ConvertToDoubleInt64(); + var result = Vector128.ConvertToDouble(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = Vector128.ConvertToDouble(_fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = Vector128.ConvertToDouble(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int64[] firstOp, Double[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + if (result[0] != (double)(firstOp[0])) + { + succeeded = false; + } + else + { + for (var i = 1; i < RetElementCount; i++) + { + if (result[i] != (double)(firstOp[i])) + { + succeeded = false; + break; + } + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(Vector128)}.{nameof(Vector128.ConvertToDouble)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.Double.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.UInt64.cs similarity index 94% rename from src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.Double.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.UInt64.cs index 145513db669d5..df5518208f5aa 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.Double.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToDouble.UInt64.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToDoubleDouble() + private static void ConvertToDoubleUInt64() { - var test = new VectorUnaryOpTest__ConvertToDoubleDouble(); + var test = new VectorUnaryOpTest__ConvertToDoubleUInt64(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToDoubleDouble() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleDouble + public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleUInt64 { private struct DataTable { @@ -107,13 +107,13 @@ public static TestStruct Create() { var testStruct = new TestStruct(); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleDouble testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleUInt64 testClass) { var result = Vector128.ConvertToDouble(_fld1); @@ -135,20 +135,20 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleDouble testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToDoubleDouble() + static VectorUnaryOpTest__ConvertToDoubleUInt64() { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToDoubleDouble() + public VectorUnaryOpTest__ConvertToDoubleUInt64() { Succeeded = true; - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } _dataTable = new DataTable(_data1, new Double[RetElementCount], LargestVectorSize); } @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToDoubleDouble(); + var test = new VectorUnaryOpTest__ConvertToDoubleUInt64(); var result = Vector128.ConvertToDouble(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt32.Int32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt32.Single.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt32.Int32.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt32.Single.cs index efcd0171107c1..d80b9246cac5b 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt32.Int32.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt32.Single.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToInt32Int32() + private static void ConvertToInt32Single() { - var test = new VectorUnaryOpTest__ConvertToInt32Int32(); + var test = new VectorUnaryOpTest__ConvertToInt32Single(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToInt32Int32() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToInt32Int32 + public sealed unsafe class VectorUnaryOpTest__ConvertToInt32Single { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Int32 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Single testClass) { var result = Vector128.ConvertToInt32(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Int32 testClas private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToInt32Int32() + static VectorUnaryOpTest__ConvertToInt32Single() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToInt32Int32() + public VectorUnaryOpTest__ConvertToInt32Single() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToInt32Int32(); + var test = new VectorUnaryOpTest__ConvertToInt32Single(); var result = Vector128.ConvertToInt32(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt64.Int64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt64.Double.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt64.Int64.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt64.Double.cs index e8cae40603daa..f3fc95fc84062 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt64.Int64.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToInt64.Double.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToInt64Int64() + private static void ConvertToInt64Double() { - var test = new VectorUnaryOpTest__ConvertToInt64Int64(); + var test = new VectorUnaryOpTest__ConvertToInt64Double(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToInt64Int64() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToInt64Int64 + public sealed unsafe class VectorUnaryOpTest__ConvertToInt64Double { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Int64 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Double testClass) { var result = Vector128.ConvertToInt64(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Int64 testClas private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToInt64Int64() + static VectorUnaryOpTest__ConvertToInt64Double() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToInt64Int64() + public VectorUnaryOpTest__ConvertToInt64Double() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToInt64Int64(); + var test = new VectorUnaryOpTest__ConvertToInt64Double(); var result = Vector128.ConvertToInt64(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.Int32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.Int32.cs new file mode 100644 index 0000000000000..0fe365a8c42f3 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.Int32.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +namespace JIT.HardwareIntrinsics.General +{ + public static partial class Program + { + private static void ConvertToSingleInt32() + { + var test = new VectorUnaryOpTest__ConvertToSingleInt32(); + + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + // Validates passing a static member works + test.RunClsVarScenario(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class VectorUnaryOpTest__ConvertToSingleInt32 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int32[] inArray1, Single[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleInt32 testClass) + { + var result = Vector128.ConvertToSingle(_fld1); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int32); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Single); + + private static Int32[] _data1 = new Int32[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static VectorUnaryOpTest__ConvertToSingleInt32() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public VectorUnaryOpTest__ConvertToSingleInt32() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + _dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize); + } + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = Vector128.ConvertToSingle( + Unsafe.Read>(_dataTable.inArray1Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var method = typeof(Vector128).GetMethod(nameof(Vector128.ConvertToSingle), new Type[] { + typeof(Vector128) + }); + + if (method is null) + { + method = typeof(Vector128).GetMethod(nameof(Vector128.ConvertToSingle), 1, new Type[] { + typeof(Vector128<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) + }); + } + + if (method.IsGenericMethodDefinition) + { + method = method.MakeGenericMethod(typeof(Single)); + } + + var result = method.Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = Vector128.ConvertToSingle( + _clsVar1 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = Vector128.ConvertToSingle(op1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new VectorUnaryOpTest__ConvertToSingleInt32(); + var result = Vector128.ConvertToSingle(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = Vector128.ConvertToSingle(_fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = Vector128.ConvertToSingle(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int32[] firstOp, Single[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + if (result[0] != (float)(firstOp[0])) + { + succeeded = false; + } + else + { + for (var i = 1; i < RetElementCount; i++) + { + if (result[i] != (float)(firstOp[i])) + { + succeeded = false; + break; + } + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(Vector128)}.{nameof(Vector128.ConvertToSingle)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.Single.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.UInt32.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.Single.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.UInt32.cs index 1eda27aeb4244..4e153c5386cd0 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.Single.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToSingle.UInt32.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToSingleSingle() + private static void ConvertToSingleUInt32() { - var test = new VectorUnaryOpTest__ConvertToSingleSingle(); + var test = new VectorUnaryOpTest__ConvertToSingleUInt32(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToSingleSingle() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToSingleSingle + public sealed unsafe class VectorUnaryOpTest__ConvertToSingleUInt32 { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleSingle testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleUInt32 testClass) { var result = Vector128.ConvertToSingle(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleSingle testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToSingleSingle() + static VectorUnaryOpTest__ConvertToSingleUInt32() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToSingleSingle() + public VectorUnaryOpTest__ConvertToSingleUInt32() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToSingleSingle(); + var test = new VectorUnaryOpTest__ConvertToSingleUInt32(); var result = Vector128.ConvertToSingle(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt32.UInt32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt32.Single.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt32.UInt32.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt32.Single.cs index ca7ac2e86c0b2..eea5b36f6a29c 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt32.UInt32.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt32.Single.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToUInt32UInt32() + private static void ConvertToUInt32Single() { - var test = new VectorUnaryOpTest__ConvertToUInt32UInt32(); + var test = new VectorUnaryOpTest__ConvertToUInt32Single(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToUInt32UInt32() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToUInt32UInt32 + public sealed unsafe class VectorUnaryOpTest__ConvertToUInt32Single { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32UInt32 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32Single testClass) { var result = Vector128.ConvertToUInt32(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32UInt32 testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToUInt32UInt32() + static VectorUnaryOpTest__ConvertToUInt32Single() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToUInt32UInt32() + public VectorUnaryOpTest__ConvertToUInt32Single() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToUInt32UInt32(); + var test = new VectorUnaryOpTest__ConvertToUInt32Single(); var result = Vector128.ConvertToUInt32(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt64.UInt64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt64.Double.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt64.UInt64.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt64.Double.cs index 5daaa41706b37..97d6baf271096 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt64.UInt64.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/ConvertToUInt64.Double.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToUInt64UInt64() + private static void ConvertToUInt64Double() { - var test = new VectorUnaryOpTest__ConvertToUInt64UInt64(); + var test = new VectorUnaryOpTest__ConvertToUInt64Double(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToUInt64UInt64() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToUInt64UInt64 + public sealed unsafe class VectorUnaryOpTest__ConvertToUInt64Double { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64UInt64 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64Double testClass) { var result = Vector128.ConvertToUInt64(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64UInt64 testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToUInt64UInt64() + static VectorUnaryOpTest__ConvertToUInt64Double() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToUInt64UInt64() + public VectorUnaryOpTest__ConvertToUInt64Double() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToUInt64UInt64(); + var test = new VectorUnaryOpTest__ConvertToUInt64Double(); var result = Vector128.ConvertToUInt64(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector128/Program.Vector128.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector128/Program.Vector128.cs index 89e18b139dd95..8922def81ffa0 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector128/Program.Vector128.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector128/Program.Vector128.cs @@ -73,14 +73,14 @@ static Program() ["ConditionalSelect.UInt16"] = ConditionalSelectUInt16, ["ConditionalSelect.UInt32"] = ConditionalSelectUInt32, ["ConditionalSelect.UInt64"] = ConditionalSelectUInt64, - ["ConvertToDouble.Double"] = ConvertToDoubleDouble, - ["ConvertToDouble.Double"] = ConvertToDoubleDouble, - ["ConvertToInt32.Int32"] = ConvertToInt32Int32, - ["ConvertToInt64.Int64"] = ConvertToInt64Int64, - ["ConvertToSingle.Single"] = ConvertToSingleSingle, - ["ConvertToSingle.Single"] = ConvertToSingleSingle, - ["ConvertToUInt32.UInt32"] = ConvertToUInt32UInt32, - ["ConvertToUInt64.UInt64"] = ConvertToUInt64UInt64, + ["ConvertToDouble.Int64"] = ConvertToDoubleInt64, + ["ConvertToDouble.UInt64"] = ConvertToDoubleUInt64, + ["ConvertToInt32.Single"] = ConvertToInt32Single, + ["ConvertToInt64.Double"] = ConvertToInt64Double, + ["ConvertToSingle.Int32"] = ConvertToSingleInt32, + ["ConvertToSingle.UInt32"] = ConvertToSingleUInt32, + ["ConvertToUInt32.Single"] = ConvertToUInt32Single, + ["ConvertToUInt64.Double"] = ConvertToUInt64Double, ["Create.Byte"] = CreateByte, ["Create.Double"] = CreateDouble, ["Create.Int16"] = CreateInt16, diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.Int64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.Int64.cs new file mode 100644 index 0000000000000..fe9013bbd8797 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.Int64.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +namespace JIT.HardwareIntrinsics.General +{ + public static partial class Program + { + private static void ConvertToDoubleInt64() + { + var test = new VectorUnaryOpTest__ConvertToDoubleInt64(); + + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + // Validates passing a static member works + test.RunClsVarScenario(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleInt64 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int64[] inArray1, Double[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector256 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleInt64 testClass) + { + var result = Vector256.ConvertToDouble(_fld1); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + + private static readonly int LargestVectorSize = 32; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int64); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Double); + + private static Int64[] _data1 = new Int64[Op1ElementCount]; + + private static Vector256 _clsVar1; + + private Vector256 _fld1; + + private DataTable _dataTable; + + static VectorUnaryOpTest__ConvertToDoubleInt64() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public VectorUnaryOpTest__ConvertToDoubleInt64() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + _dataTable = new DataTable(_data1, new Double[RetElementCount], LargestVectorSize); + } + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = Vector256.ConvertToDouble( + Unsafe.Read>(_dataTable.inArray1Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var method = typeof(Vector256).GetMethod(nameof(Vector256.ConvertToDouble), new Type[] { + typeof(Vector256) + }); + + if (method is null) + { + method = typeof(Vector256).GetMethod(nameof(Vector256.ConvertToDouble), 1, new Type[] { + typeof(Vector256<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) + }); + } + + if (method.IsGenericMethodDefinition) + { + method = method.MakeGenericMethod(typeof(Double)); + } + + var result = method.Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = Vector256.ConvertToDouble( + _clsVar1 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = Vector256.ConvertToDouble(op1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new VectorUnaryOpTest__ConvertToDoubleInt64(); + var result = Vector256.ConvertToDouble(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = Vector256.ConvertToDouble(_fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = Vector256.ConvertToDouble(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + private void ValidateResult(Vector256 op1, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int64[] firstOp, Double[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + if (result[0] != (double)(firstOp[0])) + { + succeeded = false; + } + else + { + for (var i = 1; i < RetElementCount; i++) + { + if (result[i] != (double)(firstOp[i])) + { + succeeded = false; + break; + } + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(Vector256)}.{nameof(Vector256.ConvertToDouble)}(Vector256): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.Double.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.UInt64.cs similarity index 94% rename from src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.Double.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.UInt64.cs index dff3948ab50e8..86254208e18a6 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.Double.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToDouble.UInt64.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToDoubleDouble() + private static void ConvertToDoubleUInt64() { - var test = new VectorUnaryOpTest__ConvertToDoubleDouble(); + var test = new VectorUnaryOpTest__ConvertToDoubleUInt64(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToDoubleDouble() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleDouble + public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleUInt64 { private struct DataTable { @@ -107,13 +107,13 @@ public static TestStruct Create() { var testStruct = new TestStruct(); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleDouble testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleUInt64 testClass) { var result = Vector256.ConvertToDouble(_fld1); @@ -135,20 +135,20 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleDouble testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToDoubleDouble() + static VectorUnaryOpTest__ConvertToDoubleUInt64() { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToDoubleDouble() + public VectorUnaryOpTest__ConvertToDoubleUInt64() { Succeeded = true; - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } _dataTable = new DataTable(_data1, new Double[RetElementCount], LargestVectorSize); } @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToDoubleDouble(); + var test = new VectorUnaryOpTest__ConvertToDoubleUInt64(); var result = Vector256.ConvertToDouble(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt32.Int32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt32.Single.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt32.Int32.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt32.Single.cs index 569a73ea81a8f..82a26d00455b2 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt32.Int32.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt32.Single.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToInt32Int32() + private static void ConvertToInt32Single() { - var test = new VectorUnaryOpTest__ConvertToInt32Int32(); + var test = new VectorUnaryOpTest__ConvertToInt32Single(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToInt32Int32() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToInt32Int32 + public sealed unsafe class VectorUnaryOpTest__ConvertToInt32Single { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Int32 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Single testClass) { var result = Vector256.ConvertToInt32(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Int32 testClas private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToInt32Int32() + static VectorUnaryOpTest__ConvertToInt32Single() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToInt32Int32() + public VectorUnaryOpTest__ConvertToInt32Single() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToInt32Int32(); + var test = new VectorUnaryOpTest__ConvertToInt32Single(); var result = Vector256.ConvertToInt32(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt64.Int64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt64.Double.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt64.Int64.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt64.Double.cs index 35a40c15a5857..250121dc448fe 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt64.Int64.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToInt64.Double.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToInt64Int64() + private static void ConvertToInt64Double() { - var test = new VectorUnaryOpTest__ConvertToInt64Int64(); + var test = new VectorUnaryOpTest__ConvertToInt64Double(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToInt64Int64() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToInt64Int64 + public sealed unsafe class VectorUnaryOpTest__ConvertToInt64Double { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Int64 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Double testClass) { var result = Vector256.ConvertToInt64(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Int64 testClas private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToInt64Int64() + static VectorUnaryOpTest__ConvertToInt64Double() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToInt64Int64() + public VectorUnaryOpTest__ConvertToInt64Double() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToInt64Int64(); + var test = new VectorUnaryOpTest__ConvertToInt64Double(); var result = Vector256.ConvertToInt64(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.Int32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.Int32.cs new file mode 100644 index 0000000000000..902d6ddfddb67 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.Int32.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +namespace JIT.HardwareIntrinsics.General +{ + public static partial class Program + { + private static void ConvertToSingleInt32() + { + var test = new VectorUnaryOpTest__ConvertToSingleInt32(); + + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + // Validates passing a static member works + test.RunClsVarScenario(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class VectorUnaryOpTest__ConvertToSingleInt32 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int32[] inArray1, Single[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector256 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleInt32 testClass) + { + var result = Vector256.ConvertToSingle(_fld1); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + + private static readonly int LargestVectorSize = 32; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int32); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Single); + + private static Int32[] _data1 = new Int32[Op1ElementCount]; + + private static Vector256 _clsVar1; + + private Vector256 _fld1; + + private DataTable _dataTable; + + static VectorUnaryOpTest__ConvertToSingleInt32() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public VectorUnaryOpTest__ConvertToSingleInt32() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + _dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize); + } + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = Vector256.ConvertToSingle( + Unsafe.Read>(_dataTable.inArray1Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var method = typeof(Vector256).GetMethod(nameof(Vector256.ConvertToSingle), new Type[] { + typeof(Vector256) + }); + + if (method is null) + { + method = typeof(Vector256).GetMethod(nameof(Vector256.ConvertToSingle), 1, new Type[] { + typeof(Vector256<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) + }); + } + + if (method.IsGenericMethodDefinition) + { + method = method.MakeGenericMethod(typeof(Single)); + } + + var result = method.Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = Vector256.ConvertToSingle( + _clsVar1 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = Vector256.ConvertToSingle(op1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new VectorUnaryOpTest__ConvertToSingleInt32(); + var result = Vector256.ConvertToSingle(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = Vector256.ConvertToSingle(_fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = Vector256.ConvertToSingle(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + private void ValidateResult(Vector256 op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int32[] firstOp, Single[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + if (result[0] != (float)(firstOp[0])) + { + succeeded = false; + } + else + { + for (var i = 1; i < RetElementCount; i++) + { + if (result[i] != (float)(firstOp[i])) + { + succeeded = false; + break; + } + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(Vector256)}.{nameof(Vector256.ConvertToSingle)}(Vector256): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.Single.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.UInt32.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.Single.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.UInt32.cs index 3c4cdbd8cb01d..a5f8fbea9a822 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.Single.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToSingle.UInt32.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToSingleSingle() + private static void ConvertToSingleUInt32() { - var test = new VectorUnaryOpTest__ConvertToSingleSingle(); + var test = new VectorUnaryOpTest__ConvertToSingleUInt32(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToSingleSingle() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToSingleSingle + public sealed unsafe class VectorUnaryOpTest__ConvertToSingleUInt32 { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleSingle testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleUInt32 testClass) { var result = Vector256.ConvertToSingle(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleSingle testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToSingleSingle() + static VectorUnaryOpTest__ConvertToSingleUInt32() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToSingleSingle() + public VectorUnaryOpTest__ConvertToSingleUInt32() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToSingleSingle(); + var test = new VectorUnaryOpTest__ConvertToSingleUInt32(); var result = Vector256.ConvertToSingle(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt32.UInt32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt32.Single.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt32.UInt32.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt32.Single.cs index 32bb04d867485..f3e7cc0937251 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt32.UInt32.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt32.Single.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToUInt32UInt32() + private static void ConvertToUInt32Single() { - var test = new VectorUnaryOpTest__ConvertToUInt32UInt32(); + var test = new VectorUnaryOpTest__ConvertToUInt32Single(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToUInt32UInt32() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToUInt32UInt32 + public sealed unsafe class VectorUnaryOpTest__ConvertToUInt32Single { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32UInt32 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32Single testClass) { var result = Vector256.ConvertToUInt32(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32UInt32 testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToUInt32UInt32() + static VectorUnaryOpTest__ConvertToUInt32Single() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToUInt32UInt32() + public VectorUnaryOpTest__ConvertToUInt32Single() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToUInt32UInt32(); + var test = new VectorUnaryOpTest__ConvertToUInt32Single(); var result = Vector256.ConvertToUInt32(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt64.UInt64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt64.Double.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt64.UInt64.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt64.Double.cs index 8a1722650aa14..90a46927a32f9 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt64.UInt64.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/ConvertToUInt64.Double.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToUInt64UInt64() + private static void ConvertToUInt64Double() { - var test = new VectorUnaryOpTest__ConvertToUInt64UInt64(); + var test = new VectorUnaryOpTest__ConvertToUInt64Double(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToUInt64UInt64() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToUInt64UInt64 + public sealed unsafe class VectorUnaryOpTest__ConvertToUInt64Double { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64UInt64 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64Double testClass) { var result = Vector256.ConvertToUInt64(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64UInt64 testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToUInt64UInt64() + static VectorUnaryOpTest__ConvertToUInt64Double() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToUInt64UInt64() + public VectorUnaryOpTest__ConvertToUInt64Double() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToUInt64UInt64(); + var test = new VectorUnaryOpTest__ConvertToUInt64Double(); var result = Vector256.ConvertToUInt64(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector256/Program.Vector256.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector256/Program.Vector256.cs index 89e18b139dd95..8922def81ffa0 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector256/Program.Vector256.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector256/Program.Vector256.cs @@ -73,14 +73,14 @@ static Program() ["ConditionalSelect.UInt16"] = ConditionalSelectUInt16, ["ConditionalSelect.UInt32"] = ConditionalSelectUInt32, ["ConditionalSelect.UInt64"] = ConditionalSelectUInt64, - ["ConvertToDouble.Double"] = ConvertToDoubleDouble, - ["ConvertToDouble.Double"] = ConvertToDoubleDouble, - ["ConvertToInt32.Int32"] = ConvertToInt32Int32, - ["ConvertToInt64.Int64"] = ConvertToInt64Int64, - ["ConvertToSingle.Single"] = ConvertToSingleSingle, - ["ConvertToSingle.Single"] = ConvertToSingleSingle, - ["ConvertToUInt32.UInt32"] = ConvertToUInt32UInt32, - ["ConvertToUInt64.UInt64"] = ConvertToUInt64UInt64, + ["ConvertToDouble.Int64"] = ConvertToDoubleInt64, + ["ConvertToDouble.UInt64"] = ConvertToDoubleUInt64, + ["ConvertToInt32.Single"] = ConvertToInt32Single, + ["ConvertToInt64.Double"] = ConvertToInt64Double, + ["ConvertToSingle.Int32"] = ConvertToSingleInt32, + ["ConvertToSingle.UInt32"] = ConvertToSingleUInt32, + ["ConvertToUInt32.Single"] = ConvertToUInt32Single, + ["ConvertToUInt64.Double"] = ConvertToUInt64Double, ["Create.Byte"] = CreateByte, ["Create.Double"] = CreateDouble, ["Create.Int16"] = CreateInt16, diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.Int64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.Int64.cs new file mode 100644 index 0000000000000..434e74bc4bcac --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.Int64.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +namespace JIT.HardwareIntrinsics.General +{ + public static partial class Program + { + private static void ConvertToDoubleInt64() + { + var test = new VectorUnaryOpTest__ConvertToDoubleInt64(); + + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + // Validates passing a static member works + test.RunClsVarScenario(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleInt64 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int64[] inArray1, Double[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleInt64 testClass) + { + var result = Vector64.ConvertToDouble(_fld1); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int64); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Double); + + private static Int64[] _data1 = new Int64[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static VectorUnaryOpTest__ConvertToDoubleInt64() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public VectorUnaryOpTest__ConvertToDoubleInt64() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + _dataTable = new DataTable(_data1, new Double[RetElementCount], LargestVectorSize); + } + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = Vector64.ConvertToDouble( + Unsafe.Read>(_dataTable.inArray1Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var method = typeof(Vector64).GetMethod(nameof(Vector64.ConvertToDouble), new Type[] { + typeof(Vector64) + }); + + if (method is null) + { + method = typeof(Vector64).GetMethod(nameof(Vector64.ConvertToDouble), 1, new Type[] { + typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) + }); + } + + if (method.IsGenericMethodDefinition) + { + method = method.MakeGenericMethod(typeof(Double)); + } + + var result = method.Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = Vector64.ConvertToDouble( + _clsVar1 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = Vector64.ConvertToDouble(op1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new VectorUnaryOpTest__ConvertToDoubleInt64(); + var result = Vector64.ConvertToDouble(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = Vector64.ConvertToDouble(_fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = Vector64.ConvertToDouble(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int64[] firstOp, Double[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + if (result[0] != (double)(firstOp[0])) + { + succeeded = false; + } + else + { + for (var i = 1; i < RetElementCount; i++) + { + if (result[i] != (double)(firstOp[i])) + { + succeeded = false; + break; + } + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(Vector64)}.{nameof(Vector64.ConvertToDouble)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.Double.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.UInt64.cs similarity index 94% rename from src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.Double.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.UInt64.cs index 95410e322a711..fd51e78150e1a 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.Double.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToDouble.UInt64.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToDoubleDouble() + private static void ConvertToDoubleUInt64() { - var test = new VectorUnaryOpTest__ConvertToDoubleDouble(); + var test = new VectorUnaryOpTest__ConvertToDoubleUInt64(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToDoubleDouble() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleDouble + public sealed unsafe class VectorUnaryOpTest__ConvertToDoubleUInt64 { private struct DataTable { @@ -107,13 +107,13 @@ public static TestStruct Create() { var testStruct = new TestStruct(); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleDouble testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleUInt64 testClass) { var result = Vector64.ConvertToDouble(_fld1); @@ -135,20 +135,20 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToDoubleDouble testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToDoubleDouble() + static VectorUnaryOpTest__ConvertToDoubleUInt64() { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToDoubleDouble() + public VectorUnaryOpTest__ConvertToDoubleUInt64() { Succeeded = true; - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = Math.Min(long.MaxValue, TestLibrary.Generator.GetUInt64()); } _dataTable = new DataTable(_data1, new Double[RetElementCount], LargestVectorSize); } @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToDoubleDouble(); + var test = new VectorUnaryOpTest__ConvertToDoubleUInt64(); var result = Vector64.ConvertToDouble(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt32.Int32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt32.Single.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt32.Int32.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt32.Single.cs index 521a79dfb1ba2..d38c1856993f5 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt32.Int32.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt32.Single.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToInt32Int32() + private static void ConvertToInt32Single() { - var test = new VectorUnaryOpTest__ConvertToInt32Int32(); + var test = new VectorUnaryOpTest__ConvertToInt32Single(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToInt32Int32() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToInt32Int32 + public sealed unsafe class VectorUnaryOpTest__ConvertToInt32Single { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Int32 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Single testClass) { var result = Vector64.ConvertToInt32(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt32Int32 testClas private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToInt32Int32() + static VectorUnaryOpTest__ConvertToInt32Single() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToInt32Int32() + public VectorUnaryOpTest__ConvertToInt32Single() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToInt32Int32(); + var test = new VectorUnaryOpTest__ConvertToInt32Single(); var result = Vector64.ConvertToInt32(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt64.Int64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt64.Double.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt64.Int64.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt64.Double.cs index 303c872d583a4..139da25fb67aa 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt64.Int64.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToInt64.Double.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToInt64Int64() + private static void ConvertToInt64Double() { - var test = new VectorUnaryOpTest__ConvertToInt64Int64(); + var test = new VectorUnaryOpTest__ConvertToInt64Double(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToInt64Int64() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToInt64Int64 + public sealed unsafe class VectorUnaryOpTest__ConvertToInt64Double { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Int64 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Double testClass) { var result = Vector64.ConvertToInt64(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToInt64Int64 testClas private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToInt64Int64() + static VectorUnaryOpTest__ConvertToInt64Double() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToInt64Int64() + public VectorUnaryOpTest__ConvertToInt64Double() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToInt64Int64(); + var test = new VectorUnaryOpTest__ConvertToInt64Double(); var result = Vector64.ConvertToInt64(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.Int32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.Int32.cs new file mode 100644 index 0000000000000..f0c6f3736114b --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.Int32.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +namespace JIT.HardwareIntrinsics.General +{ + public static partial class Program + { + private static void ConvertToSingleInt32() + { + var test = new VectorUnaryOpTest__ConvertToSingleInt32(); + + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + // Validates passing a static member works + test.RunClsVarScenario(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class VectorUnaryOpTest__ConvertToSingleInt32 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int32[] inArray1, Single[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 32 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleInt32 testClass) + { + var result = Vector64.ConvertToSingle(_fld1); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int32); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Single); + + private static Int32[] _data1 = new Int32[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static VectorUnaryOpTest__ConvertToSingleInt32() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public VectorUnaryOpTest__ConvertToSingleInt32() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + _dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize); + } + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = Vector64.ConvertToSingle( + Unsafe.Read>(_dataTable.inArray1Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var method = typeof(Vector64).GetMethod(nameof(Vector64.ConvertToSingle), new Type[] { + typeof(Vector64) + }); + + if (method is null) + { + method = typeof(Vector64).GetMethod(nameof(Vector64.ConvertToSingle), 1, new Type[] { + typeof(Vector64<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) + }); + } + + if (method.IsGenericMethodDefinition) + { + method = method.MakeGenericMethod(typeof(Single)); + } + + var result = method.Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = Vector64.ConvertToSingle( + _clsVar1 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = Vector64.ConvertToSingle(op1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new VectorUnaryOpTest__ConvertToSingleInt32(); + var result = Vector64.ConvertToSingle(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = Vector64.ConvertToSingle(_fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = Vector64.ConvertToSingle(test._fld1); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int32[] firstOp, Single[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + if (result[0] != (float)(firstOp[0])) + { + succeeded = false; + } + else + { + for (var i = 1; i < RetElementCount; i++) + { + if (result[i] != (float)(firstOp[i])) + { + succeeded = false; + break; + } + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(Vector64)}.{nameof(Vector64.ConvertToSingle)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.Single.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.UInt32.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.Single.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.UInt32.cs index 4a1673f667733..4e52f26dc79a6 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.Single.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToSingle.UInt32.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToSingleSingle() + private static void ConvertToSingleUInt32() { - var test = new VectorUnaryOpTest__ConvertToSingleSingle(); + var test = new VectorUnaryOpTest__ConvertToSingleUInt32(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToSingleSingle() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToSingleSingle + public sealed unsafe class VectorUnaryOpTest__ConvertToSingleUInt32 { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleSingle testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleUInt32 testClass) { var result = Vector64.ConvertToSingle(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToSingleSingle testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToSingleSingle() + static VectorUnaryOpTest__ConvertToSingleUInt32() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToSingleSingle() + public VectorUnaryOpTest__ConvertToSingleUInt32() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToSingleSingle(); + var test = new VectorUnaryOpTest__ConvertToSingleUInt32(); var result = Vector64.ConvertToSingle(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt32.UInt32.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt32.Single.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt32.UInt32.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt32.Single.cs index 314417d948647..37c6d5c32a314 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt32.UInt32.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt32.Single.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToUInt32UInt32() + private static void ConvertToUInt32Single() { - var test = new VectorUnaryOpTest__ConvertToUInt32UInt32(); + var test = new VectorUnaryOpTest__ConvertToUInt32Single(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToUInt32UInt32() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToUInt32UInt32 + public sealed unsafe class VectorUnaryOpTest__ConvertToUInt32Single { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32UInt32 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32Single testClass) { var result = Vector64.ConvertToUInt32(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt32UInt32 testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToUInt32UInt32() + static VectorUnaryOpTest__ConvertToUInt32Single() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToUInt32UInt32() + public VectorUnaryOpTest__ConvertToUInt32Single() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToUInt32UInt32(); + var test = new VectorUnaryOpTest__ConvertToUInt32Single(); var result = Vector64.ConvertToUInt32(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt64.UInt64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt64.Double.cs similarity index 97% rename from src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt64.UInt64.cs rename to src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt64.Double.cs index 12abbb8843356..4cc3ca81f6970 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt64.UInt64.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/ConvertToUInt64.Double.cs @@ -17,9 +17,9 @@ namespace JIT.HardwareIntrinsics.General { public static partial class Program { - private static void ConvertToUInt64UInt64() + private static void ConvertToUInt64Double() { - var test = new VectorUnaryOpTest__ConvertToUInt64UInt64(); + var test = new VectorUnaryOpTest__ConvertToUInt64Double(); // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); @@ -52,7 +52,7 @@ private static void ConvertToUInt64UInt64() } } - public sealed unsafe class VectorUnaryOpTest__ConvertToUInt64UInt64 + public sealed unsafe class VectorUnaryOpTest__ConvertToUInt64Double { private struct DataTable { @@ -113,7 +113,7 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64UInt64 testClass) + public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64Double testClass) { var result = Vector64.ConvertToUInt64(_fld1); @@ -135,13 +135,13 @@ public void RunStructFldScenario(VectorUnaryOpTest__ConvertToUInt64UInt64 testCl private DataTable _dataTable; - static VectorUnaryOpTest__ConvertToUInt64UInt64() + static VectorUnaryOpTest__ConvertToUInt64Double() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); } - public VectorUnaryOpTest__ConvertToUInt64UInt64() + public VectorUnaryOpTest__ConvertToUInt64Double() { Succeeded = true; @@ -221,7 +221,7 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new VectorUnaryOpTest__ConvertToUInt64UInt64(); + var test = new VectorUnaryOpTest__ConvertToUInt64Double(); var result = Vector64.ConvertToUInt64(test._fld1); Unsafe.Write(_dataTable.outArrayPtr, result); diff --git a/src/tests/JIT/HardwareIntrinsics/General/Vector64/Program.Vector64.cs b/src/tests/JIT/HardwareIntrinsics/General/Vector64/Program.Vector64.cs index 8275581825316..c000608c2bef6 100644 --- a/src/tests/JIT/HardwareIntrinsics/General/Vector64/Program.Vector64.cs +++ b/src/tests/JIT/HardwareIntrinsics/General/Vector64/Program.Vector64.cs @@ -73,14 +73,14 @@ static Program() ["ConditionalSelect.UInt16"] = ConditionalSelectUInt16, ["ConditionalSelect.UInt32"] = ConditionalSelectUInt32, ["ConditionalSelect.UInt64"] = ConditionalSelectUInt64, - ["ConvertToDouble.Double"] = ConvertToDoubleDouble, - ["ConvertToDouble.Double"] = ConvertToDoubleDouble, - ["ConvertToInt32.Int32"] = ConvertToInt32Int32, - ["ConvertToInt64.Int64"] = ConvertToInt64Int64, - ["ConvertToSingle.Single"] = ConvertToSingleSingle, - ["ConvertToSingle.Single"] = ConvertToSingleSingle, - ["ConvertToUInt32.UInt32"] = ConvertToUInt32UInt32, - ["ConvertToUInt64.UInt64"] = ConvertToUInt64UInt64, + ["ConvertToDouble.Int64"] = ConvertToDoubleInt64, + ["ConvertToDouble.UInt64"] = ConvertToDoubleUInt64, + ["ConvertToInt32.Single"] = ConvertToInt32Single, + ["ConvertToInt64.Double"] = ConvertToInt64Double, + ["ConvertToSingle.Int32"] = ConvertToSingleInt32, + ["ConvertToSingle.UInt32"] = ConvertToSingleUInt32, + ["ConvertToUInt32.Single"] = ConvertToUInt32Single, + ["ConvertToUInt64.Double"] = ConvertToUInt64Double, ["Create.Byte"] = CreateByte, ["Create.Double"] = CreateDouble, ["Create.Int16"] = CreateInt16,