diff options
author | Tanner Gooding <tagoo@outlook.com> | 2019-05-09 13:46:38 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-05-09 13:46:38 -0700 |
commit | a74e710efb386677fc3b5c651b22213e996c0f72 (patch) | |
tree | 4bb169e475c9849066a3ed0cf3607d0392601354 /tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs | |
parent | 2ff7aaac87a976a86c07b93867efb9ade391eed3 (diff) | |
download | coreclr-a74e710efb386677fc3b5c651b22213e996c0f72.tar.gz coreclr-a74e710efb386677fc3b5c651b22213e996c0f72.tar.bz2 coreclr-a74e710efb386677fc3b5c651b22213e996c0f72.zip |
More cleanup of the HWIntrinsic test templates (#24455)
* Adding some templates from which other HWIntrinsic test templates can be generated
* Regenerating the HWIntrinsic tests
Diffstat (limited to 'tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs')
-rw-r--r-- | tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs | 93 |
1 files changed, 73 insertions, 20 deletions
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs index 575224186c..ad86d2c4d0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs @@ -121,6 +121,59 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class SimpleBinaryOpTest__MultiplyLowUInt16 { + private struct DataTable + { + private byte[] inArray1; + private byte[] inArray2; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle inHandle2; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(UInt16[] inArray1, UInt16[] inArray2, UInt16[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<UInt16>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<UInt16>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt16>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray2 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<UInt16, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<UInt16, byte>(ref inArray2[0]), (uint)sizeOfinArray2); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + inHandle2.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<UInt16> _fld1; @@ -177,7 +230,7 @@ namespace JIT.HardwareIntrinsics.X86 private Vector128<UInt16> _fld1; private Vector128<UInt16> _fld2; - private SimpleBinaryOpTest__DataTable<UInt16, UInt16, UInt16> _dataTable; + private DataTable _dataTable; static SimpleBinaryOpTest__MultiplyLowUInt16() { @@ -198,7 +251,7 @@ namespace JIT.HardwareIntrinsics.X86 for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetUInt16(); } - _dataTable = new SimpleBinaryOpTest__DataTable<UInt16, UInt16, UInt16>(_data1, _data2, new UInt16[RetElementCount], LargestVectorSize); + _dataTable = new DataTable(_data1, _data2, new UInt16[RetElementCount], LargestVectorSize); } public bool IsSupported => Sse2.IsSupported; @@ -320,36 +373,36 @@ namespace JIT.HardwareIntrinsics.X86 { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - var left = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr); - var right = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr); - var result = Sse2.MultiplyLow(left, right); + var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr); + var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr); + var result = Sse2.MultiplyLow(op1, op2); Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); + ValidateResult(op1, op2, _dataTable.outArrayPtr); } public void RunLclVarScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - var left = Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)); - var right = Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)); - var result = Sse2.MultiplyLow(left, right); + var op1 = Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)); + var op2 = Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)); + var result = Sse2.MultiplyLow(op1, op2); Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); + ValidateResult(op1, op2, _dataTable.outArrayPtr); } public void RunLclVarScenario_LoadAligned() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - var left = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)); - var right = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)); - var result = Sse2.MultiplyLow(left, right); + var op1 = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)); + var op2 = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)); + var result = Sse2.MultiplyLow(op1, op2); Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); + ValidateResult(op1, op2, _dataTable.outArrayPtr); } public void RunClassLclFldScenario() @@ -471,27 +524,27 @@ namespace JIT.HardwareIntrinsics.X86 } } - private void ValidateResult(Vector128<UInt16> left, Vector128<UInt16> right, void* result, [CallerMemberName] string method = "") + private void ValidateResult(Vector128<UInt16> op1, Vector128<UInt16> op2, void* result, [CallerMemberName] string method = "") { UInt16[] inArray1 = new UInt16[Op1ElementCount]; UInt16[] inArray2 = new UInt16[Op2ElementCount]; UInt16[] outArray = new UInt16[RetElementCount]; - Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), left); - Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), right); + Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1); + Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), op2); Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>()); ValidateResult(inArray1, inArray2, outArray, method); } - private void ValidateResult(void* left, void* right, void* result, [CallerMemberName] string method = "") + private void ValidateResult(void* op1, void* op2, void* result, [CallerMemberName] string method = "") { UInt16[] inArray1 = new UInt16[Op1ElementCount]; UInt16[] inArray2 = new UInt16[Op2ElementCount]; UInt16[] outArray = new UInt16[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), (uint)Unsafe.SizeOf<Vector128<UInt16>>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), (uint)Unsafe.SizeOf<Vector128<UInt16>>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt16>>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector128<UInt16>>()); Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>()); ValidateResult(inArray1, inArray2, outArray, method); |