diff options
author | Carol Eidt <carol.eidt@microsoft.com> | 2018-03-30 11:36:04 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2018-03-30 11:36:04 -0700 |
commit | 17de92ef10d5a56db312fd368671912e614741a6 (patch) | |
tree | 94b31b6573ebecf7fece7f69b34e85cd06e4b865 | |
parent | cce06fbc204aa13ab65b77ccd878d7d851a697d1 (diff) | |
parent | 10f51a06623fb11f1760c8b2aeea196e137deea0 (diff) | |
download | coreclr-17de92ef10d5a56db312fd368671912e614741a6.tar.gz coreclr-17de92ef10d5a56db312fd368671912e614741a6.tar.bz2 coreclr-17de92ef10d5a56db312fd368671912e614741a6.zip |
Merge pull request #17314 from fiigii/fixgctests
Fix GCStress failures from hardware intrinsic tests
10 files changed, 185 insertions, 213 deletions
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs index 207dcff702..6f87416366 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs @@ -24,27 +24,35 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle2; private GCHandle outHandle; - private byte simdSize; + private ulong alignment; - public AlternatingBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int simdSize) + public AlternatingBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int alignment) { - this.inArray1 = new byte[simdSize * 2]; - this.inArray2 = new byte[simdSize * 2]; - this.outArray = new byte[simdSize * 2]; + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>(); + 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.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2); } - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize); + 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() { @@ -53,19 +61,9 @@ namespace JIT.HardwareIntrinsics.X86 outHandle.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs index f3822fa09a..b2683ced77 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs @@ -21,24 +21,31 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle1; private GCHandle inHandle2; - private byte simdSize; + private ulong alignment; - public BooleanBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int simdSize) + public BooleanBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int alignment) { - this.inArray1 = new byte[simdSize * 2]; - this.inArray2 = new byte[simdSize * 2]; + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray2 = new byte[alignment * 2]; this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned); - this.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2); } - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize); + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment); public void Dispose() { @@ -46,19 +53,9 @@ namespace JIT.HardwareIntrinsics.X86 inHandle2.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs index 051baa0f5d..557b560d54 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs @@ -21,24 +21,31 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle1; private GCHandle inHandle2; - private byte simdSize; + private ulong alignment; - public BooleanComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int simdSize) + public BooleanComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int alignment) { - this.inArray1 = new byte[simdSize * 2]; - this.inArray2 = new byte[simdSize * 2]; + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray2 = new byte[alignment * 2]; this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned); - this.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2); } - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize); + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment); public void Dispose() { @@ -46,19 +53,9 @@ namespace JIT.HardwareIntrinsics.X86 inHandle2.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs index 618b284632..f2ab635c56 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs @@ -21,24 +21,31 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle1; private GCHandle inHandle2; - private byte simdSize; + private ulong alignment; - public BooleanTwoComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int simdSize) + public BooleanTwoComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int alignment) { - this.inArray1 = new byte[simdSize * 2]; - this.inArray2 = new byte[simdSize * 2]; + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray2 = new byte[alignment * 2]; this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned); - this.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2); } - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize); + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment); public void Dispose() { @@ -46,19 +53,9 @@ namespace JIT.HardwareIntrinsics.X86 inHandle2.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs index cd478f3dca..a94532413d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs @@ -18,39 +18,34 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle; - private byte simdSize; + private ulong alignment; - public BooleanUnaryOpTest__DataTable(TOp1[] inArray, int simdSize) + public BooleanUnaryOpTest__DataTable(TOp1[] inArray, int alignment) { - this.inArray = new byte[simdSize * 2]; + int sizeOfinArray = inArray.Length * Unsafe.SizeOf<TOp1>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + this.inArray = new byte[alignment * 2]; this.inHandle = GCHandle.Alloc(this.inArray, GCHandleType.Pinned); - this.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), (uint)sizeOfinArray); } - public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), simdSize); + public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), alignment); public void Dispose() { inHandle.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs index ac69cd8564..e9b6123066 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs @@ -24,27 +24,35 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle2; private GCHandle outHandle; - private byte simdSize; + private ulong alignment; - public HorizontalBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int simdSize) + public HorizontalBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int alignment) { - this.inArray1 = new byte[simdSize * 2]; - this.inArray2 = new byte[simdSize * 2]; - this.outArray = new byte[simdSize * 2]; + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>(); + 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.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2); } - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize); + 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() { @@ -53,19 +61,9 @@ namespace JIT.HardwareIntrinsics.X86 outHandle.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs index b510aed999..2d5532d7ab 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs @@ -18,37 +18,32 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle outHandle; - private byte simdSize; + private ulong alignment; - public SimpleScalarUnaryOpTest__DataTable(TResult[] outArray, int simdSize) + public SimpleScalarUnaryOpTest__DataTable(TResult[] outArray, int alignment) { - this.outArray = new byte[simdSize * 2]; + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + this.outArray = new byte[alignment * 2]; this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - this.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; } - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); public void Dispose() { outHandle.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs index ff80da4e88..eae18a2368 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs @@ -24,27 +24,35 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle2; private GCHandle outHandle; - private byte simdSize; + private ulong alignment; - public SimpleBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int simdSize) + public SimpleBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int alignment) { - this.inArray1 = new byte[simdSize * 2]; - this.inArray2 = new byte[simdSize * 2]; - this.outArray = new byte[simdSize * 2]; + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>(); + 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.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2); } - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize); + 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() { @@ -53,19 +61,9 @@ namespace JIT.HardwareIntrinsics.X86 outHandle.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs index 8c6014509a..dbc9ac1f90 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs @@ -27,31 +27,41 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle3; private GCHandle outHandle; - private byte simdSize; + private ulong alignment; - public SimpleTernaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TOp3[] inArray3, TResult[] outArray, int simdSize) + public SimpleTernaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TOp3[] inArray3, TResult[] outArray, int alignment) { - this.inArray1 = new byte[simdSize * 2]; - this.inArray2 = new byte[simdSize * 2]; - this.inArray3 = new byte[simdSize * 2]; - this.outArray = new byte[simdSize * 2]; + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>(); + int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<TOp3>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || + (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray2 = new byte[alignment * 2]; + this.inArray3 = 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.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned); this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - this.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize); - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<TOp3, byte>(ref inArray3[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<TOp3, byte>(ref inArray3[0]), (uint)sizeOfinArray3); } - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize); - public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), simdSize); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize); + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); public void Dispose() { @@ -61,19 +71,9 @@ namespace JIT.HardwareIntrinsics.X86 outHandle.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs index 5240a21919..efda580ad0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs @@ -21,23 +21,30 @@ namespace JIT.HardwareIntrinsics.X86 private GCHandle inHandle; private GCHandle outHandle; - private byte simdSize; + private ulong alignment; - public SimpleUnaryOpTest__DataTable(TOp1[] inArray, TResult[] outArray, int simdSize) + public SimpleUnaryOpTest__DataTable(TOp1[] inArray, TResult[] outArray, int alignment) { - this.inArray = new byte[simdSize * 2]; - this.outArray = new byte[simdSize * 2]; + int sizeOfinArray = inArray.Length * Unsafe.SizeOf<TOp1>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>(); + if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; this.inHandle = GCHandle.Alloc(this.inArray, GCHandleType.Pinned); this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - this.simdSize = unchecked((byte)(simdSize)); + this.alignment = (ulong)alignment; - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), this.simdSize); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), (uint)sizeOfinArray); } - public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), simdSize); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize); + public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); public void Dispose() { @@ -45,19 +52,9 @@ namespace JIT.HardwareIntrinsics.X86 outHandle.Free(); } - private static unsafe void* Align(byte* buffer, byte expectedAlignment) + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) { - // Compute how bad the misalignment is, which is at most (expectedAlignment - 1). - // Then subtract that from the expectedAlignment and add it to the original address - // to compute the aligned address. - - var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment); - var result = (void*)(buffer + misalignment); - - Debug.Assert(((ulong)(result) % expectedAlignment) == 0); - Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment)); - - return result; + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); } } } |